Format: Bloom subset of https://www.debian.org/doc/packaging-manuals/copyright-format/1.0/
Upstream-Name: gtsam

Files: See file headers in repository for details
Copyright: See package copyright in source code for details
License: BSD-3-Clause
 See repository for full license text

Files: See file headers in repository for details
Copyright: See package copyright in source code for details
License: BSD-3-Clause
 CCOLAMD: constrained column approximate minimum degree ordering
 Copyright (C) 2005-2016, Univ. of Florida.  Authors: Timothy A. Davis,
 Sivasankaran Rajamanickam, and Stefan Larimore.  Closely based on COLAMD by
 Davis, Stefan Larimore, in collaboration with Esmond Ng, and John Gilbert.
 http://www.suitesparse.com
 .
 --------------------------------------------------------------------------------
 .
 CCOLAMD license: BSD 3-clause:
 .
     Redistribution and use in source and binary forms, with or without
     modification, are permitted provided that the following conditions are met:
         * Redistributions of source code must retain the above copyright
           notice, this list of conditions and the following disclaimer.
         * Redistributions in binary form must reproduce the above copyright
           notice, this list of conditions and the following disclaimer in the
           documentation and/or other materials provided with the distribution.
         * Neither the name of the organizations to which the authors are
           affiliated, nor the names of its contributors may be used to endorse
           or promote products derived from this software without specific prior
           written permission.
 .
     THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
     AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
     IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
     ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDERS BE LIABLE FOR ANY
     DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
     (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
     SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
     CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
     LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
     OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH
     DAMAGE.

Files: See file headers in repository for details
Copyright: See package copyright in source code for details
License: MPL-2.0
 Eigen is primarily MPL2 licensed. See COPYING.MPL2 and these links:
   http://www.mozilla.org/MPL/2.0/
   http://www.mozilla.org/MPL/2.0/FAQ.html
 .
 Some files contain third-party code under BSD or LGPL licenses, whence the other
 COPYING.* files here.
 .
 All the LGPL code is either LGPL 2.1-only, or LGPL 2.1-or-later.
 For this reason, the COPYING.LGPL file contains the LGPL 2.1 text.
 .
 If you want to guarantee that the Eigen code that you are #including is licensed
 under the MPL2 and possibly more permissive licenses (like BSD), #define this
 preprocessor symbol:
   EIGEN_MPL2_ONLY
 For example, with most compilers, you could add this to your project CXXFLAGS:
   -DEIGEN_MPL2_ONLY
 This will cause a compilation error to be generated if you #include any code that is
 LGPL licensed.

Files: See file headers in repository for details
Copyright: See package copyright in source code for details
License: Apache-2.0
 .
 Copyright & License Notice
 ---------------------------
 .
 Copyright 1995-2013, Regents of the University of Minnesota
 .
 Licensed under the Apache License, Version 2.0 (the "License");
 you may not use this file except in compliance with the License.
 You may obtain a copy of the License at
 .
 http://www.apache.org/licenses/LICENSE-2.0
 .
 Unless required by applicable law or agreed to in writing, software
 distributed under the License is distributed on an "AS IS" BASIS,
 WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or 
 implied. See the License for the specific language governing 
 permissions and limitations under the License.

Files: See file headers in repository for details
Copyright: See package copyright in source code for details
License: MPL-2.0
 // Copyright (C) 2016-2025 Yixuan Qiu <yixuan.qiu@cos.name>
 //
 // This Source Code Form is subject to the terms of the Mozilla
 // Public License v. 2.0. If a copy of the MPL was not distributed
 // with this file, You can obtain one at https://mozilla.org/MPL/2.0/.
 .
 #ifndef SPECTRA_GEN_EIGS_SOLVER_H
 #define SPECTRA_GEN_EIGS_SOLVER_H
 .
 #include <Eigen/Core>
 .
 #include "GenEigsBase.h"
 #include "Util/SelectionRule.h"
 #include "MatOp/DenseGenMatProd.h"
 .
 namespace Spectra {
 .
 ///
 /// \ingroup EigenSolver
 ///
 /// This class implements the eigen solver for general real matrices, i.e.,
 /// to solve \f$Ax=\lambda x\f$ for a possibly non-symmetric \f$A\f$ matrix.
 ///
 /// Most of the background information documented in the SymEigsSolver class
 /// also applies to the GenEigsSolver class here, except that the eigenvalues
 /// and eigenvectors of a general matrix can now be complex-valued.
 ///
 /// \tparam OpType  The name of the matrix operation class. Users could either
 ///                 use the wrapper classes such as DenseGenMatProd and
 ///                 SparseGenMatProd, or define their own that implements the type
 ///                 definition `Scalar` and all the public member functions as in
 ///                 DenseGenMatProd.
 ///
 /// An example that illustrates the usage of GenEigsSolver is give below:
 ///
 /// \code{.cpp}
 /// #include <Eigen/Core>
 /// #include <Spectra/GenEigsSolver.h>
 /// // <Spectra/MatOp/DenseGenMatProd.h> is implicitly included
 /// #include <iostream>
 ///
 /// using namespace Spectra;
 ///
 /// int main()
 /// {
 ///     // We are going to calculate the eigenvalues of M
 ///     Eigen::MatrixXd M = Eigen::MatrixXd::Random(10, 10);
 ///
 ///     // Construct matrix operation object using the wrapper class
 ///     DenseGenMatProd<double> op(M);
 ///
 ///     // Construct eigen solver object, requesting the largest
 ///     // (in magnitude, or norm) three eigenvalues
 ///     GenEigsSolver<DenseGenMatProd<double>> eigs(op, 3, 6);
 ///
 ///     // Initialize and compute
 ///     eigs.init();
 ///     int nconv = eigs.compute(SortRule::LargestMagn);
 ///
 ///     // Retrieve results
 ///     Eigen::VectorXcd evalues;
 ///     if (eigs.info() == CompInfo::Successful)
 ///         evalues = eigs.eigenvalues();
 ///
 ///     std::cout << "Eigenvalues found:\n" << evalues << std::endl;
 ///
 ///     return 0;
 /// }
 /// \endcode
 ///
 /// And also an example for sparse matrices:
 ///
 /// \code{.cpp}
 /// #include <Eigen/Core>
 /// #include <Eigen/SparseCore>
 /// #include <Spectra/GenEigsSolver.h>
 /// #include <Spectra/MatOp/SparseGenMatProd.h>
 /// #include <iostream>
 ///
 /// using namespace Spectra;
 ///
 /// int main()
 /// {
 ///     // A band matrix with 1 on the main diagonal, 2 on the below-main subdiagonal,
 ///     // and 3 on the above-main subdiagonal
 ///     const int n = 10;
 ///     Eigen::SparseMatrix<double> M(n, n);
 ///     M.reserve(Eigen::VectorXi::Constant(n, 3));
 ///     for (int i = 0; i < n; i++)
 ///     {
 ///         M.insert(i, i) = 1.0;
 ///         if (i > 0)
 ///             M.insert(i - 1, i) = 3.0;
 ///         if (i < n - 1)
 ///             M.insert(i + 1, i) = 2.0;
 ///     }
 ///
 ///     // Construct matrix operation object using the wrapper class SparseGenMatProd
 ///     SparseGenMatProd<double> op(M);
 ///
 ///     // Construct eigen solver object, requesting the largest three eigenvalues
 ///     GenEigsSolver<SparseGenMatProd<double>> eigs(op, 3, 6);
 ///
 ///     // Initialize and compute
 ///     eigs.init();
 ///     int nconv = eigs.compute(SortRule::LargestMagn);
 ///
 ///     // Retrieve results
 ///     Eigen::VectorXcd evalues;
 ///     if (eigs.info() == CompInfo::Successful)
 ///         evalues = eigs.eigenvalues();
 ///
 ///     std::cout << "Eigenvalues found:\n" << evalues << std::endl;
 ///
 ///     return 0;
 /// }
 /// \endcode
 template <typename OpType = DenseGenMatProd<double>>
 class GenEigsSolver : public GenEigsBase<OpType, IdentityBOp>
 {
 private:
     using Index = Eigen::Index;
 .
 public:
     ///
     /// Constructor to create a solver object.
     ///
     /// \param op   The matrix operation object that implements
     ///             the matrix-vector multiplication operation of \f$A\f$:
     ///             calculating \f$Av\f$ for any vector \f$v\f$. Users could either
     ///             create the object from the wrapper class such as DenseGenMatProd, or
     ///             define their own that implements all the public members
     ///             as in DenseGenMatProd.
     /// \param nev  Number of eigenvalues requested. This should satisfy \f$1\le nev \le n-2\f$,
     ///             where \f$n\f$ is the size of matrix.
     /// \param ncv  Parameter that controls the convergence speed of the algorithm.
     ///             Typically a larger `ncv` means faster convergence, but it may
     ///             also result in greater memory use and more matrix operations
     ///             in each iteration. This parameter must satisfy \f$nev+2 \le ncv \le n\f$,
     ///             and is advised to take \f$ncv \ge 2\cdot nev + 1\f$.
     ///
     GenEigsSolver(OpType& op, Index nev, Index ncv) :
         GenEigsBase<OpType, IdentityBOp>(op, IdentityBOp(), nev, ncv)
     {}
 };
 .
 }  // namespace Spectra
 .
 #endif  // SPECTRA_GEN_EIGS_SOLVER_H
