cbcintlinprog added

1 files changed, 0 insertions, 339 deletions

diff --git a/newstructure/thirdparty/linux/include/coin/IpCompoundVector.hpp b/newstructure/thirdparty/linux/include/coin/IpCompoundVector.hpp
deleted file mode 100644
index a4c52ab..0000000
--- a/newstructure/thirdparty/linux/include/coin/IpCompoundVector.hpp
+++ /dev/null
@@ -1,339 +0,0 @@
-// Copyright (C) 2004, 2006 International Business Machines and others.
-// All Rights Reserved.
-// This code is published under the Eclipse Public License.
-//
-// $Id: IpCompoundVector.hpp 2269 2013-05-05 11:32:40Z stefan $
-//
-// Authors:  Carl Laird, Andreas Waechter     IBM    2004-08-13
-
-#ifndef __IPCOMPOUNDVECTOR_HPP__
-#define __IPCOMPOUNDVECTOR_HPP__
-
-#include "IpUtils.hpp"
-#include "IpVector.hpp"
-#include <vector>
-
-namespace Ipopt
-{
-
-  /* forward declarations */
-  class CompoundVectorSpace;
-
-  /** Class of Vectors consisting of other vectors.  This vector is a
-   *  vector that consists of zero, one or more Vector's which are
-   *  stacked on each others: \f$ x_{\rm compound} =
-   *  \left(\begin{array}{c}x_0\\\dots\\x_{{\rm
-   *  ncomps} - 1}\end{array}\right)\f$.  The individual components can be
-   *  associated to different VectorSpaces.  The individual components
-   *  can also be const and non-const Vectors.
-   */
-  class CompoundVector : public Vector
-  {
-  public:
-    /**@name Constructors/Destructors */
-    //@{
-    /** Constructor, given the corresponding CompoundVectorSpace.
-     *  Before this constructor can be called, all components of the
-     *  CompoundVectorSpace have to be set, so that the constructors
-     *  for the individual components can be called.  If the flag
-     *  create_new is true, then the individual components of the new
-     *  CompoundVector are initialized with the MakeNew methods of
-     *  each VectorSpace (and are non-const).  Otherwise, the
-     *  individual components can later be set using the SetComp and
-     *  SetCompNonConst method.
-     */
-    CompoundVector(const CompoundVectorSpace* owner_space, bool create_new);
-
-    /** Default destructor */
-    virtual ~CompoundVector();
-    //@}
-
-    /** Method for setting the pointer for a component that is a const
-     *  Vector
-     */
-    void SetComp(Index icomp, const Vector& vec);
-
-    /** Method for setting the pointer for a component that is a
-     *  non-const Vector
-     */
-    void SetCompNonConst(Index icomp, Vector& vec);
-
-    /** Number of components of this compound vector */
-    inline Index NComps() const;
-
-    /** Check if a particular component is const or not */
-    bool IsCompConst(Index i) const
-    {
-      DBG_ASSERT(i > 0 && i < NComps());
-      DBG_ASSERT(IsValid(comps_[i]) || IsValid(const_comps_[i]));
-      if (IsValid(const_comps_[i])) {
-        return true;
-      }
-      return false;
-    }
-
-    /** Check if a particular component is null or not */
-    bool IsCompNull(Index i) const
-    {
-      DBG_ASSERT(i >= 0 && i < NComps());
-      if (IsValid(comps_[i]) || IsValid(const_comps_[i])) {
-        return false;
-      }
-      return true;
-    }
-
-    /** Return a particular component (const version) */
-    SmartPtr<const Vector> GetComp(Index i) const
-    {
-      return ConstComp(i);
-    }
-
-    /** Return a particular component (non-const version).  Note that
-     *  calling this method with mark the CompoundVector as changed.
-     *  Therefore, only use this method if you are intending to change
-     *  the Vector that you receive.
-     */
-    SmartPtr<Vector> GetCompNonConst(Index i)
-    {
-      ObjectChanged();
-      return Comp(i);
-    }
-
-  protected:
-    /** @name Overloaded methods from Vector base class */
-    //@{
-    /** Copy the data of the vector x into this vector (DCOPY). */
-    virtual void CopyImpl(const Vector& x);
-
-    /** Scales the vector by scalar alpha (DSCAL) */
-    virtual void ScalImpl(Number alpha);
-
-    /** Add the multiple alpha of vector x to this vector (DAXPY) */
-    virtual void AxpyImpl(Number alpha, const Vector &x);
-
-    /** Computes inner product of vector x with this (DDOT) */
-    virtual Number DotImpl(const Vector &x) const;
-
-    /** Computes the 2-norm of this vector (DNRM2) */
-    virtual Number Nrm2Impl() const;
-
-    /** Computes the 1-norm of this vector (DASUM) */
-    virtual Number AsumImpl() const;
-
-    /** Computes the max-norm of this vector (based on IDAMAX) */
-    virtual Number AmaxImpl() const;
-
-    /** Set each element in the vector to the scalar alpha. */
-    virtual void SetImpl(Number value);
-
-    /** Element-wise division  \f$y_i \gets y_i/x_i\f$.*/
-    virtual void ElementWiseDivideImpl(const Vector& x);
-
-    /** Element-wise multiplication \f$y_i \gets y_i*x_i\f$.*/
-    virtual void ElementWiseMultiplyImpl(const Vector& x);
-
-    /** Element-wise max against entries in x */
-    virtual void ElementWiseMaxImpl(const Vector& x);
-
-    /** Element-wise min against entries in x */
-    virtual void ElementWiseMinImpl(const Vector& x);
-
-    /** Element-wise reciprocal */
-    virtual void ElementWiseReciprocalImpl();
-
-    /** Element-wise absolute values */
-    virtual void ElementWiseAbsImpl();
-
-    /** Element-wise square-root */
-    virtual void ElementWiseSqrtImpl();
-
-    /** Replaces entries with sgn of the entry */
-    virtual void ElementWiseSgnImpl();
-
-    /** Add scalar to every component of the vector.*/
-    virtual void AddScalarImpl(Number scalar);
-
-    /** Max value in the vector */
-    virtual Number MaxImpl() const;
-
-    /** Min value in the vector */
-    virtual Number MinImpl() const;
-
-    /** Computes the sum of the lements of vector */
-    virtual Number SumImpl() const;
-
-    /** Computes the sum of the logs of the elements of vector */
-    virtual Number SumLogsImpl() const;
-
-    /** @name Implemented specialized functions */
-    //@{
-    /** Add two vectors (a * v1 + b * v2).  Result is stored in this
-    vector. */
-    void AddTwoVectorsImpl(Number a, const Vector& v1,
-                           Number b, const Vector& v2, Number c);
-    /** Fraction to the boundary parameter. */
-    Number FracToBoundImpl(const Vector& delta, Number tau) const;
-    /** Add the quotient of two vectors, y = a * z/s + c * y. */
-    void AddVectorQuotientImpl(Number a, const Vector& z, const Vector& s,
-                               Number c);
-    //@}
-
-    /** Method for determining if all stored numbers are valid (i.e.,
-     *  no Inf or Nan). */
-    virtual bool HasValidNumbersImpl() const;
-
-    /** @name Output methods */
-    //@{
-    /* Print the entire vector with padding */
-    virtual void PrintImpl(const Journalist& jnlst,
-                           EJournalLevel level,
-                           EJournalCategory category,
-                           const std::string& name,
-                           Index indent,
-                           const std::string& prefix) const;
-    //@}
-
-  private:
-    /**@name Default Compiler Generated Methods
-     * (Hidden to avoid implicit creation/calling).
-     * These methods are not implemented and 
-     * we do not want the compiler to implement
-     * them for us, so we declare them private
-     * and do not define them. This ensures that
-     * they will not be implicitly created/called.
-     */
-    //@{
-    /** Default Constructor */
-    CompoundVector();
-
-    /** Copy Constructor */
-    CompoundVector(const CompoundVector&);
-
-    /** Overloaded Equals Operator */
-    void operator=(const CompoundVector&);
-    //@}
-
-    /** Components of the compound vector.  The components
-     *  are stored by SmartPtrs in a std::vector
-     */
-    std::vector< SmartPtr<Vector> > comps_;
-    std::vector< SmartPtr<const Vector> > const_comps_;
-
-    const CompoundVectorSpace* owner_space_;
-
-    bool vectors_valid_;
-
-    bool VectorsValid();
-
-    inline const Vector* ConstComp(Index i) const;
-
-    inline Vector* Comp(Index i);
-  };
-
-  /** This vectors space is the vector space for CompoundVector.
-   *  Before a CompoundVector can be created, all components of this
-   *  CompoundVectorSpace have to be set.  When calling the constructor,
-   *  the number of component has to be specified.  The individual
-   *  VectorSpaces can be set with the SetComp method.
-   */
-  class CompoundVectorSpace : public VectorSpace
-  {
-  public:
-    /** @name Constructors/Destructors. */
-    //@{
-    /** Constructor, has to be given the number of components and the
-     *  total dimension of all components combined. */
-    CompoundVectorSpace(Index ncomp_spaces, Index total_dim);
-
-    /** Destructor */
-    ~CompoundVectorSpace()
-    {}
-    //@}
-
-    /** Method for setting the individual component VectorSpaces */
-    virtual void SetCompSpace(Index icomp                  /** Number of the component to be set */ ,
-                              const VectorSpace& vec_space /** VectorSpace for component icomp */
-                             );
-
-    /** Method for obtaining an individual component VectorSpace */
-    SmartPtr<const VectorSpace> GetCompSpace(Index icomp) const;
-
-    /** Accessor method to obtain the number of components */
-    Index NCompSpaces() const
-    {
-      return ncomp_spaces_;
-    }
-
-    /** Method for creating a new vector of this specific type. */
-    virtual CompoundVector* MakeNewCompoundVector(bool create_new = true) const
-    {
-      return new CompoundVector(this, create_new);
-    }
-
-    /** Overloaded MakeNew method for the VectorSpace base class.
-     */
-    virtual Vector* MakeNew() const
-    {
-      return MakeNewCompoundVector();
-    }
-
-  private:
-    /**@name Default Compiler Generated Methods
-     * (Hidden to avoid implicit creation/calling).
-     * These methods are not implemented and 
-     * we do not want the compiler to implement
-     * them for us, so we declare them private
-     * and do not define them. This ensures that
-     * they will not be implicitly created/called. */
-    //@{
-    /** Default constructor */
-    CompoundVectorSpace();
-
-    /** Copy Constructor */
-    CompoundVectorSpace(const CompoundVectorSpace&);
-
-    /** Overloaded Equals Operator */
-    CompoundVectorSpace& operator=(const CompoundVectorSpace&);
-    //@}
-
-    /** Number of components */
-    const Index ncomp_spaces_;
-
-    /** std::vector of vector spaces for the components */
-    std::vector< SmartPtr<const VectorSpace> > comp_spaces_;
-  };
-
-  /* inline methods */
-  inline
-  Index CompoundVector::NComps() const
-  {
-    return owner_space_->NCompSpaces();
-  }
-
-  inline
-  const Vector* CompoundVector::ConstComp(Index i) const
-  {
-    DBG_ASSERT(i < NComps());
-    DBG_ASSERT(IsValid(comps_[i]) || IsValid(const_comps_[i]));
-    if (IsValid(comps_[i])) {
-      return GetRawPtr(comps_[i]);
-    }
-    else if (IsValid(const_comps_[i])) {
-      return GetRawPtr(const_comps_[i]);
-    }
-
-    DBG_ASSERT(false && "shouldn't be here");
-    return NULL;
-  }
-
-  inline
-  Vector* CompoundVector::Comp(Index i)
-  {
-    DBG_ASSERT(i < NComps());
-    DBG_ASSERT(IsValid(comps_[i]));
-    return GetRawPtr(comps_[i]);
-  }
-
-} // namespace Ipopt
-
-#endif