Operators_vector.tpp

/*---------------------------------------------------------------------------*\
 *
 *  bitpit
 *
 *  Copyright (C) 2015-2021 OPTIMAD engineering Srl
 *
 *  -------------------------------------------------------------------------
 *  License
 *  This file is part of bitpit.
 *
 *  bitpit is free software: you can redistribute it and/or modify it
 *  under the terms of the GNU Lesser General Public License v3 (LGPL)
 *  as published by the Free Software Foundation.
 *
 *  bitpit is distributed in the hope that it will be useful, but WITHOUT
 *  ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
 *  FITNESS FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public
 *  License for more details.
 *
 *  You should have received a copy of the GNU Lesser General Public License
 *  along with bitpit. If not, see <http://www.gnu.org/licenses/>.
 *
\*---------------------------------------------------------------------------*/
 
// ================================================================================== //
//                                  OPERATORS                                         //
//                                                                                    //
// Operators for standard template library vectors.                                   //
// ================================================================================== //
// INFO                                                                               //
// ================================================================================== //
// Author     : Alessandro Alaia                                                      //
// Version    : v3.0                                                                  //
//                                                                                    //
// All rights reserved.                                                               //
// ================================================================================== //
 
// ================================================================================== //
// TEMPLATE IMPLEMENTATION                                                            //
// ================================================================================== //
 
// Operator "+" ===================================================================== //
 
// ---------------------------------------------------------------------------------- //
template <class T>
std::vector< T > operator+ (
  const std::vector< T >                        &x,
  const std::vector< T >                        &y
) {
 
// ================================================================================== //
// VARIABLES DECLARATION                                                              //
// ================================================================================== //
size_t             n = std::min(x.size(), y.size());
std::vector< T >        z(n, T(0));
 
// ================================================================================== //
// PERFORM SUM                                                                        //
// ================================================================================== //
for (size_t i = 0; i < n; i++){
    z[i] = x[i] + y[i];
};
 
return (z); };
 
// ---------------------------------------------------------------------------------- //
template <class T>
std::vector< T > operator+ (
  const std::vector< T >                        &x,
  const T                                       &y
) {
 
// ================================================================================== //
// VARIABLES DECLARATION                                                              //
// ================================================================================== //
size_t              n = x.size();
std::vector< T >         z(n, T(0));
 
// ================================================================================== //
// PERFORM SUM                                                                        //
// ================================================================================== //
for (size_t i = 0; i < n; i++){
    z[i] = x[i] + y;
};
 
return (z); };
 
// ---------------------------------------------------------------------------------- //
template <class T>
std::vector< T > operator+ (
  const T                                       &x,
  const std::vector< T >                        &y
) {
 
// ================================================================================== //
// VARIABLES DECLARATION                                                              //
// ================================================================================== //
std::vector< T >   z;
 
// ================================================================================== //
// PERFORM SUM                                                                        //
// ================================================================================== //
z = y + x;
 
return (z); };
 
// ---------------------------------------------------------------------------------- //
template <class T>
std::vector< std::vector< T > > operator+ (
    const std::vector< std::vector< T > >       &x,
    const T                                     &y
) {
 
// ================================================================================== //
// VARIABLES DECLARATION                                                              //
// ================================================================================== //
size_t                  n = x.size();
std::vector< std::vector< T > >   z(n);
 
// ================================================================================== //
// PERFORM SUM                                                                        //
// ================================================================================== //
for (size_t i = 0; i < n; i++) {
    z[i] = x[i] + y;
} //next i
 
return (z); };
 
// ---------------------------------------------------------------------------------- //
template <class T>
std::vector< std::vector< T > > operator+ (
    const T                                     &x,
    const std::vector< std::vector< T > >       &y
) {
 
// ================================================================================== //
// VARIABLES DECLARATION                                                              //
// ================================================================================== //
std::vector< std::vector< T > >   z;
 
// ================================================================================== //
// PERFORM SUM                                                                        //
// ================================================================================== //
z = y + x;
 
return (z); };
 
// Operator "+=" ==================================================================== //
 
// ---------------------------------------------------------------------------------- //
template <class T>
std::vector< T >& operator+= (
  std::vector< T >                              &x,
  const std::vector< T >                        &y
) {
 
    // ================================================================================== //
// VARIABLES DECLARATION                                                              //
// ================================================================================== //
size_t                  n = std::min(x.size(), y.size());
 
// ================================================================================== //
// PERFORM SUM                                                                        //
// ================================================================================== //
for (size_t i = 0; i < n; i++){
    x[i] += y[i];
};
 
return (x); };
 
// ---------------------------------------------------------------------------------- //
template <class T>
std::vector< T >& operator+= (
  std::vector< T >                              &x,
  const T                                       &y
) {
 
// ================================================================================== //
// VARIABLES DECLARATION                                                              //
// ================================================================================== //
size_t              n = x.size();
 
// ================================================================================== //
// PERFORM SUM                                                                        //
// ================================================================================== //
for (size_t i = 0; i < n; i++){
    x[i] += y;
};
 
return (x); };
 
// ---------------------------------------------------------------------------------- //
template <class T>
std::vector< std::vector< T > >& operator+= (
    std::vector< std::vector< T > >             &x,
    const T                                     &y
) {
 
// ================================================================================== //
// VARIABLES DECLARATION                                                              //
// ================================================================================== //
size_t                  n = x.size();
 
// ================================================================================== //
// PERFORM SUM                                                                        //
// ================================================================================== //
for (size_t i = 0; i < n; i++) {
    x[i] += y;
} //next i
 
return (x); };
 
// Operator "-" ===================================================================== //
 
// ---------------------------------------------------------------------------------- //
template <class T>
std::vector< T > operator- (
  const std::vector< T >                        &x,
  const std::vector< T >                        &y
) {
 
// ================================================================================== //
// VARIABLES DECLARATION                                                              //
// ================================================================================== //
size_t              n = std::min(x.size(), y.size());
std::vector< T >         z(n, T(0));
 
// ================================================================================== //
// PERFORM DIFFERENCE                                                                 //
// ================================================================================== //
for (size_t i = 0; i < n; i++){
    z[i] = x[i] - y[i];
};
 
return(z); };
 
// ---------------------------------------------------------------------------------- //
template <class T>
std::vector< T > operator- (
  const std::vector< T >                        &x,
  const T                                       &y
) {
 
// ================================================================================== //
// VARIABLES DECLARATION                                                              //
// ================================================================================== //
size_t              n = x.size();
std::vector< T >         z(n, T(0));
 
// ================================================================================== //
// PERFORM DIFFERENCE                                                                 //
// ================================================================================== //
for (size_t i = 0; i < n; i++){
    z[i] = x[i] - y;
};
 
return(z); };
 
// ---------------------------------------------------------------------------------- //
template <class T>
std::vector< T > operator- (
  const T                                       &x,
  const std::vector< T >                        &y
) {
 
// ================================================================================== //
// VARIABLES DECLARATION                                                              //
// ================================================================================== //
std::vector< T >   z;
 
// =================================================================================== //
// PERFORM DIFFERENCE                                                                  //
// =================================================================================== //
z = y - x;
 
return(z); };
 
// ---------------------------------------------------------------------------------- //
template <class T>
std::vector< std::vector< T > > operator- (
  const T                                       &x,
  const std::vector< std::vector< T > >         &y
) {
 
// ================================================================================== //
// VARIABLES DECLARATION                                                              //
// ================================================================================== //
size_t                  n = y.size();
std::vector< std::vector< T > >   z(n);
 
// ================================================================================== //
// PERFORM DIFFERENCE                                                                 //
// ================================================================================== //
for (size_t i = 0; i < n; i++) {
    z[i] = x - y[i];
} //next i
 
return(z); };
 
// ---------------------------------------------------------------------------------- //
template <class T>
std::vector< std::vector< T > > operator- (
  const std::vector< std::vector< T > >         &x,
  const T                                       &y
) {
 
// ================================================================================== //
// VARIABLES DECLARATION                                                              //
// ================================================================================== //
std::vector< std::vector< T > >   z;
 
// ================================================================================== //
// PERFORM DIFFERENCE                                                                 //
// ================================================================================== //
z = y - x;
 
return(z); };
 
// Operator "-=" ==================================================================== //
 
// ---------------------------------------------------------------------------------- //
template <class T>
std::vector< T >& operator-= (
  std::vector< T >                              &x,
  const std::vector< T >                        &y
) {
 
// ================================================================================== //
// VARIABLES DECLARATION                                                              //
// ================================================================================== //
size_t                  n = std::min(x.size(), y.size());
 
// ================================================================================== //
// PERFORM SUM                                                                        //
// ================================================================================== //
for (size_t i = 0; i < n; i++){
    x[i] -= y[i];
};
 
return (x); };
 
// ---------------------------------------------------------------------------------- //
template <class T>
std::vector< T >& operator-= (
  std::vector< T >                              &x,
  const T                                       &y
) {
 
// ================================================================================== //
// VARIABLES DECLARATION                                                              //
// ================================================================================== //
size_t              n = x.size();
 
// ================================================================================== //
// PERFORM SUM                                                                        //
// ================================================================================== //
for (size_t i = 0; i < n; i++){
    x[i] -= y;
};
 
return (x); };
 
// ---------------------------------------------------------------------------------- //
template <class T>
std::vector< std::vector< T > >& operator-= (
    std::vector< std::vector< T > >             &x,
    const T                                     &y
) {
 
// ================================================================================== //
// VARIABLES DECLARATION                                                              //
// ================================================================================== //
size_t                  n = x.size();
 
// ================================================================================== //
// PERFORM SUM                                                                        //
// ================================================================================== //
for (size_t i = 0; i < n; i++) {
    x[i] -= y;
} //next i
 
return (x); };
 
// Operator "*" ===================================================================== //
 
// ---------------------------------------------------------------------------------- //
template <class T>
std::vector< T > operator* (
  const std::vector< T >                        &x,
  const std::vector< T >                        &y
) {
 
// ================================================================================== //
// VARIABLES DECLARATION                                                              //
// ================================================================================== //
size_t             n = std::min(x.size(), y.size());
std::vector<T>          z(n, T(0));
 
// ================================================================================== //
// PERFORM PRODUCT                                                                    //
// ================================================================================== //
for (size_t i = 0; i < n; i++){
    z[i] = x[i] * y[i];
};
 
return(z); };
 
// ---------------------------------------------------------------------------------- //
template <class T>
std::vector< T > operator* (
  const std::vector< T >                        &x,
  const T                                       &y
) {
 
// ================================================================================== //
// VARIABLES DECLARATION                                                              //
// ================================================================================== //
size_t             n = x.size();
std::vector< T >        z(n, T(0));
 
// =================================================================================== //
// PERFORM PRODUCT                                                                     //
// =================================================================================== //
for (size_t i = 0; i < n; i++){
    z[i] = x[i] * y;
};
 
return(z); };
 
// ---------------------------------------------------------------------------------- //
template <class T>
std::vector< T > operator* (
  const T                                       &x,
  const std::vector< T >                        &y
) {
 
// ================================================================================== //
// VARIABLES DECLARATION                                                              //
// ================================================================================== //
std::vector< T >   z;                                                                     
 
// ================================================================================== //
// PERFORM PRODUCT                                                                    //
// ================================================================================== //
z = y * x;
 
return(z); };
 
// ---------------------------------------------------------------------------------- //
template <class T>
std::vector< std::vector< T > > operator* (
  const T                                       &x,
  const std::vector< std::vector< T > >         &y
) {
 
// ================================================================================== //
// VARIABLES DECLARATION                                                              //
// ================================================================================== //
size_t                  n = y.size();
std::vector< std::vector< T > >   z(n);
 
// ================================================================================== //
// PERFORM PRODUCT                                                                    //
// ================================================================================== //
for (size_t i = 0; i < n; i++) {
    z[i] = x * y[i];
} //next i
 
return(z); };
 
// ---------------------------------------------------------------------------------- //
template <class T>
std::vector< std::vector< T > > operator* (
  const std::vector< std::vector< T > >         &x,
  const T                                       &y
) {
 
// ================================================================================== //
// VARIABLES DECLARATION                                                              //
// ================================================================================== //
std::vector< std::vector< T > >   z;
 
// ================================================================================== //
// PERFORM PRODUCT                                                                    //
// ================================================================================== //
z = y*x;
 
return(z); };
 
// Operator "*=" ==================================================================== //
 
// ---------------------------------------------------------------------------------- //
template <class T>
std::vector< T >& operator*= (
  std::vector< T >                              &x,
  const std::vector< T >                        &y
) {
 
    // ================================================================================== //
// VARIABLES DECLARATION                                                              //
// ================================================================================== //
size_t                  n = std::min(x.size(), y.size());
 
// ================================================================================== //
// PERFORM SUM                                                                        //
// ================================================================================== //
for (size_t i = 0; i < n; i++){
    x[i] *= y[i];
};
 
return (x); };
 
// ---------------------------------------------------------------------------------- //
template <class T>
std::vector< T >& operator*= (
  std::vector< T >                              &x,
  const T                                       &y
) {
 
// ================================================================================== //
// VARIABLES DECLARATION                                                              //
// ================================================================================== //
size_t              n = x.size();
 
// ================================================================================== //
// PERFORM SUM                                                                        //
// ================================================================================== //
for (size_t i = 0; i < n; i++){
    x[i] *= y;
};
 
return (x); };
 
// ---------------------------------------------------------------------------------- //
template <class T>
std::vector< std::vector< T > >& operator*= (
    std::vector< std::vector< T > >             &x,
    const T                                     &y
) {
 
// ================================================================================== //
// VARIABLES DECLARATION                                                              //
// ================================================================================== //
size_t                  n = x.size();
 
// ================================================================================== //
// PERFORM SUM                                                                        //
// ================================================================================== //
for (size_t i = 0; i < n; i++) {
    x[i] *= y;
} //next i
 
return (x); };
 
// Operator "/" ===================================================================== //
 
// ---------------------------------------------------------------------------------- //
template <class T>
std::vector< T > operator/ (
  const std::vector< T >                        &x,
  const std::vector< T >                        &y
) {
 
// ================================================================================== //
// VARIABLES DECLARATION                                                              //
// ================================================================================== //
size_t             n = std::min(x.size(), y.size());
std::vector<T>          z(n, T(0));
 
// ================================================================================== //
// PERFORM DIVISION                                                                   //
// ================================================================================== //
for (size_t i = 0; i < n; i++){
    z[i] = x[i] / y[i];
};
 
return(z); };
 
// ---------------------------------------------------------------------------------- //
template <class T>
std::vector< T > operator/ (
  const std::vector< T >                        &x,
  const T                                       &y
) {
 
// ================================================================================== //
// VARIABLES DECLARATION                                                              //
// ================================================================================== //
 
// Local variables
size_t        n = x.size();
std::vector< T >   z(n, T(0));
 
// Counters
size_t  i;
 
// ================================================================================== //
// DIVIDE X BY Y                                                                      //
// ================================================================================== //
for (i = 0; i < n; i++) {
    z[i] = x[i]/y;
}
 
return(z); };
 
// ---------------------------------------------------------------------------------- //
template <class T>
std::vector< T > operator/ (
  const T                                       &x,
  const std::vector< T >                        &y
) {
 
// ================================================================================== //
// VARIABLES DECLARATION                                                              //
// ================================================================================== //
size_t         n = y.size();
std::vector< T >    z(n);
 
// ================================================================================== //
// DIVIDE X BY Y                                                                      //
// ================================================================================== //
for (size_t i = 0; i < n; i++) {
    z[i] = x/y[i];
}
 
return(z); };
 
// ---------------------------------------------------------------------------------- //
template <class T>
std::vector< std::vector< T > > operator/ (
  const T                                       &x,
  const std::vector< std::vector< T > >         &y
) {
 
// ================================================================================== //
// VARIABLES DECLARATION                                                              //
// ================================================================================== //
size_t                  n = y.size();
std::vector< std::vector< T > >   z(n);
 
// ================================================================================== //
// DIVIDE X BY Y                                                                      //
// ================================================================================== //
for (size_t i = 0; i < n; i++) {
    z[i] = x/y[i];
}
 
return(z); };
 
// ---------------------------------------------------------------------------------- //
template <class T>
std::vector< std::vector< T > > operator/ (
  const std::vector< std::vector< T > >         &x,
  const T                                       &y
) {
 
// ================================================================================== //
// VARIABLES DECLARATION                                                              //
// ================================================================================== //
size_t                  n = x.size();
std::vector< std::vector< T > >   z(n);
 
// ================================================================================== //
// DIVIDE X BY Y                                                                      //
// ================================================================================== //
for (size_t i = 0; i < n; i++) {
    z[i] = x[i]/y;
}
 
return(z); };
 
// Operator "/=" ==================================================================== //
 
// ---------------------------------------------------------------------------------- //
template <class T>
std::vector< T >& operator/= (
  std::vector< T >                              &x,
  const std::vector< T >                        &y
) {
 
    // ================================================================================== //
// VARIABLES DECLARATION                                                              //
// ================================================================================== //
size_t                  n = std::min(x.size(), y.size());
 
// ================================================================================== //
// PERFORM SUM                                                                        //
// ================================================================================== //
for (size_t i = 0; i < n; i++){
    x[i] /= y[i];
};
 
return (x); };
 
// ---------------------------------------------------------------------------------- //
template <class T>
std::vector< T >& operator/= (
  std::vector< T >                              &x,
  const T                                       &y
) {
 
// ================================================================================== //
// VARIABLES DECLARATION                                                              //
// ================================================================================== //
size_t              n = x.size();
 
// ================================================================================== //
// PERFORM SUM                                                                        //
// ================================================================================== //
for (size_t i = 0; i < n; i++){
    x[i] /= y;
};
 
return (x); };
 
// ---------------------------------------------------------------------------------- //
template <class T>
std::vector< std::vector< T > >& operator/= (
    std::vector< std::vector< T > >             &x,
    const T                                     &y
) {
 
// ================================================================================== //
// VARIABLES DECLARATION                                                              //
// ================================================================================== //
size_t                  n = x.size();
 
// ================================================================================== //
// PERFORM SUM                                                                        //
// ================================================================================== //
for (size_t i = 0; i < n; i++) {
    x[i] /= y;
} //next i
 
return (x); };
 
// Output operator ================================================================== //
 
// ---------------------------------------------------------------------------------- //
template <class T>
std::ostream& operator<< (
    std::ostream                                &out,
    const std::vector< T >                      &x
) {
 
    // ================================================================================== //
// VARIABLES DECLARATION                                                              //
// ================================================================================== //
 
// Local variables
size_t               n = x.size();
 
// Counters
// none
 
// ================================================================================== //
// OUTPUT VECTOR CONTENT                                                              //
// ================================================================================== //
if (n == 0) return(out);
for (size_t i = 0; i < n-1; i++) {
    out << x[i] << " ";
} //next i
out << x[n-1];
 
return(out); };
 
// ---------------------------------------------------------------------------------- //
template <class T>
std::ofstream& operator<< (
    std::ofstream                               &out,
    const std::vector< T >                      &x
) {
 
// ================================================================================== //
// VARIABLES DECLARATION                                                              //
// ================================================================================== //
 
// Local variables
size_t               n = x.size();
 
// Counters
// none
 
// ================================================================================== //
// OUTPUT VECTOR CONTENT                                                              //
// ================================================================================== //
if (n == 0) {
    return(out);
}
for (size_t i = 0; i < n-1; i++) {
    out << x[i] << " ";
} //next i
out << x[n-1];
 
return(out); };
 
namespace bitpit {
 
// Output operator ================================================================== //
 
// ---------------------------------------------------------------------------------- //
template <class T>
Logger& operator<< (
    Logger                                      &out,
    const std::vector< T >                      &x
) {
 
    // ================================================================================== //
// VARIABLES DECLARATION                                                              //
// ================================================================================== //
 
// Local variables
size_t               n = x.size();
 
// Counters
// none
 
// ================================================================================== //
// OUTPUT VECTOR CONTENT                                                              //
// ================================================================================== //
if (n == 0) return(out);
for (size_t i = 0; i < n-1; i++) {
    out << x[i] << " ";
} //next i
out << x[n-1];
 
return(out); };
 
}
 
// Input operator =================================================================== //
 
// ---------------------------------------------------------------------------------- //
template <class T>
std::istream& operator>> (
    std::istream                                &in,
    std::vector< T >                            &x
) {
 
// ================================================================================== //
// VARIABLES DECLARATION                                                              //
// ================================================================================== //
 
// Local variables
T                    dummy;
size_t               n = x.size();
 
// Counters
size_t               i;
 
// ================================================================================== //
// EXTRACT STREAM CONTENT INTO VECTOR                                                 //
// ================================================================================== //
i = 0;
while ((in.good()) && (i < n)) {
    if (in >> dummy) { x[i] = dummy; i++; }
} //next i
while (in.good()) {
    if (in >> dummy) { x.push_back(dummy); }
}
 
return(in); };
 
// ---------------------------------------------------------------------------------- //
template <class T>
std::ifstream& operator>> (
    std::ifstream                               &in,
    std::vector< T >                            &x
) {
 
// ================================================================================== //
// VARIABLES DECLARATION                                                              //
// ================================================================================== //
 
// Local variables
T       dummy;
 
// Counters
int     i, n = x.size();
 
// ================================================================================== //
// EXTRACT FILE CONTENT INTO VECTOR                                                   //
// ================================================================================== //
i = 0;
while ((in.good()) && (i < n)) {
    if (in >> dummy) { x[i] = dummy; i++; }
} //next i
while (in.good()) {
    if (in >> dummy) { x.push_back(dummy); }
}
 
return(in); };
 
// Miscellanea ====================================================================== //
 
// ---------------------------------------------------------------------------------- //
template<typename T, typename std::enable_if< std::is_scalar< T >::value>::type*>
std::ostream& display(
    std::ostream                                &out,
    const T                                     &x
) {
 
// ================================================================================== //
// VARIABLES DECLARATION                                                              //
// ================================================================================== //
// none
 
// ================================================================================== //
// DISPLAY VARIABLE                                                                   //
// ================================================================================== //
out << x;
 
return(out); }
 
// ---------------------------------------------------------------------------------- //
template<class T>
std::ostream& display(
    std::ostream                                &out,
    const std::vector<T>                        &x,
    unsigned int                                 padding
) {
 
// ================================================================================== //
// VARIABLES DECLARATION                                                              //
// ================================================================================== //
 
// Counters
typename std::vector<T>::const_iterator      i, e = x.cend();
 
// ================================================================================== //
// DISPLAY VECTOR                                                                     //
// ================================================================================== //
if (x.size() == 0) {
    out << "[ ]";
    return(out);
}
out << std::string(padding, ' ') << "[ ";
--e;
for (i = x.begin(); i != e; ++i) {
    display(out, *i) << ", ";
} //next i
display(out, *e) << " ]";
 
return(out); }
 
// ---------------------------------------------------------------------------------- //
template<typename T, typename std::enable_if< std::is_scalar< T >::value>::type*>
std::ofstream& display(
    std::ofstream                               &out,
    const T                                     &x
) {
 
// ================================================================================== //
// VARIABLES DECLARATION                                                              //
// ================================================================================== //
// none
 
// ================================================================================== //
// DISPLAY VARIABLE                                                                   //
// ================================================================================== //
out << x;
 
return(out); }
 
// ---------------------------------------------------------------------------------- //
template<class T>
std::ofstream& display(
    std::ofstream                               &out,
    const std::vector<T>                        &x,
    unsigned int                                 padding
) {
 
// ================================================================================== //
// VARIABLES DECLARATION                                                              //
// ================================================================================== //
 
// Counters
typename std::vector<T>::const_iterator      i, e = x.cend();
 
// ================================================================================== //
// DISPLAY VECTOR                                                                     //
// ================================================================================== //
if (x.size() == 0) {
    out << "[ ]";
    return(out);
}
out << std::string(padding, ' ') << "[ ";
--e;
for (i = x.begin(); i != e; ++i) {
    display(out, *i) << ", ";
} //next i
display(out, *e) << " ]";
 
return(out); }