Namelist.cpp

Go to the documentation of this file.

//==============================================================================
//
//  This file is part of GNSSTk, the ARL:UT GNSS Toolkit.
//
//  The GNSSTk is free software; you can redistribute it and/or modify
//  it under the terms of the GNU Lesser General Public License as published
//  by the Free Software Foundation; either version 3.0 of the License, or
//  any later version.
//
//  The GNSSTk 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 GNSSTk; if not, write to the Free Software Foundation,
//  Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110, USA
//
//  This software was developed by Applied Research Laboratories at the
//  University of Texas at Austin.
//  Copyright 2004-2022, The Board of Regents of The University of Texas System
//
//==============================================================================
 
//==============================================================================
//
//  This software was developed by Applied Research Laboratories at the
//  University of Texas at Austin, under contract to an agency or agencies
//  within the U.S. Department of Defense. The U.S. Government retains all
//  rights to use, duplicate, distribute, disclose, or release this software.
//
//  Pursuant to DoD Directive 523024
//
//  DISTRIBUTION STATEMENT A: This software has been approved for public
//                            release, distribution is unlimited.
//
//==============================================================================
 
//------------------------------------------------------------------------------------
// system includes
#include <string>
#include <vector>
#include <algorithm>
#include <fstream> // for copyfmt
#include <ostream>
// GNSSTk
#include "Exception.hpp"
#include "StringUtils.hpp"
#include "Namelist.hpp"
 
using namespace std;
 
namespace gnsstk
{
 
   using namespace StringUtils;
 
   //---------------------------------------------------------------------------------
   // constructor given dimension - creates default labels
   Namelist::Namelist(const unsigned int& n)
   {
      try
      {
         if (n == 0)
            return;
         string name;
         for (unsigned int i = 0; i < n; i++)
         {
            ostringstream oss;
            oss << "NAME" << setw(3) << setfill('0') << i;
            name = oss.str();
            labels.push_back(name);
         }
      }
      catch (Exception& e) {
         GNSSTK_RETHROW(e);
      }
   }
 
   // explicit constructor - only a unique subset of names will be included.
   Namelist::Namelist(const std::vector<std::string>& names)
   {
      try
      {
         for (unsigned int i = 0; i < names.size(); i++)
         {
            bool unique = true;
            for (unsigned int j = i + 1; j < names.size(); j++)
            {
               if (names[i] == names[j])
               {
                  unique = false;
                  break;
               }
            }
            if (unique)
               labels.push_back(names[i]);
         }
      }
      catch (Exception& e)
      {
         GNSSTK_RETHROW(e);
      }
   }
 
   // add a name to the Namelist; throw if the name is not unique.
   Namelist& Namelist::operator+=(const std::string& name)
   {
      try
      {
         if (contains(name))
         {
            GNSSTK_THROW(Exception("Name is not unique: " + name));
         }
         labels.push_back(name);
         return *this;
      }
      catch (Exception& e)
      {
         GNSSTK_RETHROW(e);
      }
   }
 
   // remove a name from the Namelist; does nothing if the name is not found.
   Namelist& Namelist::operator-=(const std::string& name)
   {
      try
      {
         vector<string>::iterator it;
         it = find(labels.begin(), labels.end(), name);
         if (it != labels.end())
            labels.erase(it);
         return *this;
      }
      catch (Exception& e)
      {
         GNSSTK_RETHROW(e);
      }
   }
 
   // swap two elements, as given by their indexes; no effect if either index
   // is out of range.
   void Namelist::swap(const unsigned int& i, const unsigned int& j)
   {
      try
      {
         if (i == j)
         {
            return;
         }
         if (i >= labels.size() || j >= labels.size())
         {
            return;
         }
         string str = labels[i];
         labels[i]  = labels[j];
         labels[j]  = str;
      }
      catch (Exception& e)
      {
         GNSSTK_RETHROW(e);
      }
   }
 
   // reorder the list by sorting
   void Namelist::sort()
   {
      try
      {
         // compiler tries Namelist::sort() first...
         std::sort(labels.begin(), labels.end());
      }
      catch (Exception& e)
      {
         GNSSTK_RETHROW(e);
      }
   }
 
   // resize the list by either truncation or adding default names.
   void Namelist::resize(unsigned int n)
   {
      try
      {
         if (n == labels.size())
         {
            return;
         }
         int N = labels.size();
         while (labels.size() < n)
         {
            string s;
            do
            {
               ostringstream oss;
               oss << "NAME" << setw(3) << setfill('0') << N;
               s = oss.str();
               N++;
            } while (contains(s));
            labels.push_back(s);
         }
         while (labels.size() > n)
         {
            labels.pop_back();
         }
      }
      catch (Exception& e)
      {
         GNSSTK_RETHROW(e);
      }
   }
 
   // randomize the list
   void Namelist::randomize(long seed)
   {
      try
      {
         if (labels.size() <= 1)
         {
            return;
         }
 
         // random_shuffle(labels.begin(), labels.end());
         if (seed)
         {
            std::srand(seed);
         }
         for (int i = labels.size() - 1; i > 0; --i)
         {
            using std::swap;
            swap(labels[i], labels[std::rand() % (i + 1)]);
         }
      }
      catch (Exception& e)
      {
         GNSSTK_RETHROW(e);
      }
   }
 
   // is the Namelist valid? checks for repeated names
   bool Namelist::valid() const
   {
      try
      {
         for (unsigned int i = 0; i < labels.size(); i++)
            for (unsigned int j = i + 1; j < labels.size(); j++)
               if (labels[i] == labels[j])
                  return false;
         return true;
      }
      catch (Exception& e)
      {
         GNSSTK_RETHROW(e);
      }
   }
 
   // does the Namelist contain the input name?
   bool Namelist::contains(const std::string& name) const
   {
      try
      {
         for (unsigned int i = 0; i < labels.size(); i++)
         {
            if (labels[i] == name)
               return true;
         }
         return false;
      }
      catch (Exception& e)
      {
         GNSSTK_RETHROW(e);
      }
   }
 
   // are two Namelists identical, ignoring a permutation?
   bool operator==(const Namelist& N1, const Namelist& N2)
   {
      try
      {
         if (N1.size() != N2.size())
         {
            return false;
         }
         if (N1.size() == 0)
         {
            return true;
         }
         for (unsigned int i = 0; i < N1.size(); i++)
         {
            unsigned int match = 0;
            for (unsigned int j = 0; j < N2.size(); j++)
            {
               if (N1.labels[i] == N2.labels[j])
               {
                  match++;
               }
            }
            if (match != 1)
            {
               return false; // if > 1, N2 is invalid
            }
         }
         return true;
      }
      catch (Exception& e)
      {
         GNSSTK_RETHROW(e);
      }
   }
 
   // are two Namelists different, ignoring a permutation?
   bool operator!=(const Namelist& N1, const Namelist& N2)
   {
      try
      {
         return !(N1 == N2);
      }
      catch (Exception& e)
      {
         GNSSTK_RETHROW(e);
      }
   }
 
   // are two Namelists exactly identical, even considering permutations?
   bool identical(const Namelist& N1, const Namelist& N2)
   {
      try
      {
         if (N1.size() != N2.size())
         {
            return false;
         }
         if (N1.size() == 0)
         {
            return true;
         }
         for (unsigned int i = 0; i < N1.size(); i++)
         {
            if (N1.labels[i] != N2.labels[i])
               return false;
         }
         return true;
      }
      catch (Exception& e)
      {
         GNSSTK_RETHROW(e);
      }
   }
 
   // construct the subset Namelist which is common to the two input (AND)
   Namelist operator&(const Namelist& N1, const Namelist& N2)
   {
      try
      {
         Namelist N(N1);
         N &= N2;
         return N;
      }
      catch (Exception& e)
      {
         GNSSTK_RETHROW(e);
      }
   }
 
   // merge two Namelists, i.e. construct a non-redundant combination (OR)
   Namelist operator|(const Namelist& N1, const Namelist& N2)
   {
      try
      {
         Namelist N(N1);
         N |= N2;
         return N;
      }
      catch (Exception& e)
      {
         GNSSTK_RETHROW(e);
      }
   }
 
   // construct the subset Namelist which is NOT common to two others (XOR)
   Namelist operator^(const Namelist& N1, const Namelist& N2)
   {
      try
      {
         Namelist N(N1);
         N ^= N2;
         return N;
      }
      catch (Exception& e)
      {
         GNSSTK_RETHROW(e);
      }
   }
 
   // replace this with (this & input) (AND - common to both)
   Namelist& Namelist::operator&=(const Namelist& N)
   {
      try
      {
         Namelist NAND;
         for (unsigned int i = 0; i < N.labels.size(); i++)
         {
            if (contains(N.labels[i]))
            {
               NAND += N.labels[i];
            }
         }
         *this = NAND;
         return *this;
      }
      catch (Exception& e)
      {
         GNSSTK_RETHROW(e);
      }
   }
 
   // replace this with (this | input) (OR - merge - superset)
   // NB new elements must be added at the end (for class SRI).
   Namelist& Namelist::operator|=(const Namelist& N)
   {
      try
      {
         Namelist NOR(*this);
         for (unsigned int i = 0; i < N.labels.size(); i++)
         {
            if (!(contains(N.labels[i])))
            {
               NOR += N.labels[i];
            }
         }
         *this = NOR;
         return *this;
      }
      catch (Exception& e)
      {
         GNSSTK_RETHROW(e);
      }
   }
 
   // replace this with (this ^ input) (XOR - not common)
   Namelist& Namelist::operator^=(const Namelist& N)
   {
      try
      {
         unsigned int i;
         Namelist NXOR;
         for (i = 0; i < labels.size(); i++)
         {
            if (!(N.contains(labels[i])))
            {
               NXOR += labels[i];
            }
         }
         for (i = 0; i < N.labels.size(); i++)
         {
            if (!(contains(N.labels[i])))
            {
               NXOR += N.labels[i];
            }
         }
         *this = NXOR;
         return *this;
      }
      catch (Exception& e)
      {
         GNSSTK_RETHROW(e);
      }
   }
 
   /* access to a specific name, given its index; may be used as lvalue.
      string& Namelist::operator[](const unsigned int in)
     {
        if(in >= labels.size()) throw ...
        return labels[in];
     } */
 
   /* access to a specific name, given its index.
      returns 'out-of-range' if the index is out of range. */
   std::string Namelist::getName(const unsigned int in) const
   {
      try
      {
         if (in >= labels.size())
         {
            return string("out-of-range");
         }
         return labels[in];
      }
      catch (Exception& e)
      {
         GNSSTK_RETHROW(e);
      }
   }
 
   /* assign a specific name, given its index;
      no effect if the index is out of range or the name is not unique.
      return true if successful*/
   bool Namelist::setName(const unsigned int in, const std::string& name)
   {
      try
      {
         if (in >= labels.size())
         {
            return false;
         }
         if (labels[in] == name)
         {
            return true; // NB b/c contains(name) would be true..
         }
         if (contains(name))
         {
            return false;
         }
         labels[in] = name;
         return true;
      }
      catch (Exception& e)
      {
         GNSSTK_RETHROW(e);
      }
   }
 
   // return the index of the name in the list that matches the input, -1 if not found.
   int Namelist::index(const std::string& name) const
   {
      try
      {
         for (unsigned int i = 0; i < labels.size(); i++)
         {
            if (labels[i] == name)
            {
               return i;
            }
         }
         return -1;
      }
      catch (Exception& e)
      {
         GNSSTK_RETHROW(e);
      }
   }
 
   // output operator
   ostream& operator<<(ostream& os, const Namelist& N)
   {
      try
      {
         if (N.labels.size() > 0)
         {
            for (unsigned int i = 0; i < N.labels.size(); i++)
            {
               os << " / " << N.labels[i];
            }
            os << " / ";
         }
         return os;
      }
      catch (Exception& e)
      {
         GNSSTK_RETHROW(e);
      }
   }
 
   ostream& operator<<(ostream& os, const LabeledVector& LV)
   {
      try
      {
         size_t i;
         string s;
         // ofstream savefmt;
         // savefmt.copyfmt(os);
         // int wid=os.width(),prec=os.precision();
 
         // print message or blanks
         os << LV.tag << " ";
         if (LV.msg.size() > 0)
            s = LV.msg;
         else
            s = rightJustify(string(""), LV.msg.size()); // LV.wid);
         os << s << "   ";
 
         // print each label
         for (i = 0; i < LV.NL.size(); i++)
         {
            if (int(LV.NL.getName(i).size()) > LV.wid)
            {
               s = leftJustify(LV.NL.getName(i), LV.wid);
            }
            else
            {
               s = rightJustify(LV.NL.getName(i), LV.wid);
            }
            os << s;
            if (i - LV.NL.size() + 1)
            {
               os << " ";
            }
         }
         os << endl; // next line
 
         // print same space as with labels
         s = rightJustify(string(""), LV.msg.size() + 2); // LV.wid);
         os << LV.tag << " " << s << " ";
         if (LV.form == 1)
         {
            os << fixed;
         }
         if (LV.form == 2)
         {
            os << scientific;
         }
         for (i = 0; i < LV.V.size(); i++)
         {
            // os.copyfmt(savefmt);
            // os << LV.V(i);
            os << setw(LV.wid) << setprecision(LV.prec) << LV.V(i);
            if (i - LV.V.size() + 1)
            {
               os << " ";
            }
         }
 
         return os;
      }
      catch (Exception& e)
      {
         GNSSTK_RETHROW(e);
      }
   }
 
   std::ostream& operator<<(std::ostream& os, const LabeledMatrix& LM)
   {
      try
      {
         int nspace;
         size_t i, j, jlast, n;
         string s;
         const Namelist *pNLcol = &LM.NLcols;
         const Namelist *pNLrow = &LM.NLrows;
 
         // first make sure we have both namelists
         if (LM.NLrows.size() == 0 && LM.NLcols.size() == 0)
         {
            os << " Error -- Namelists in LabeledMatrix are empty! ";
            return os;
         }
         if (LM.NLrows.size() == 0)
         {
            pNLrow = pNLcol;
         }
         if (LM.NLcols.size() == 0)
         {
            pNLcol = pNLrow;
         }
 
         // on column labels line
         os << setw(0);
         if (LM.rc == 0)
         {                       // only if printing both column and row labels
            os << LM.tag << " "; // tag
            if (LM.msg.size() > 0) // msg
            {
               s = LM.msg + "  ";
            }
            else
            {
               s = rightJustify(string(" "), LM.wid);
            }
            os << s << " ";
            if (int(LM.msg.size()) > 0 && int(LM.msg.size()) < LM.wid)
            {
               os << rightJustify(string(" "), LM.wid - LM.msg.size()); // space
            }
         }
         // print column labels
         if (LM.rc != 1)
         { // but not if 'rows only'
            n = (LM.M.cols() < pNLcol->size() ? LM.M.cols() : pNLcol->size());
            if (LM.rc == 2)
            {
               os << " ";
            }
            for (i = 0; i < n; i++)
            {
               if (int(pNLcol->getName(i).size()) > LM.wid)
               {
                  s = leftJustify(pNLcol->getName(i), LM.wid);
               }
               else
               {
                  s = rightJustify(pNLcol->getName(i), LM.wid);
               }
               os << s; // label
               if (i < n - 1)
                  os << " ";
            }
            os << endl;
         }
 
         if (LM.form == 1)
         {
            os << fixed;
         }
         if (LM.form == 2)
         {
            os << scientific;
         }
         if (int(LM.msg.size()) > LM.wid)
         {
            nspace = LM.msg.size() - LM.wid + 2;
         }
         else if (int(LM.msg.size()))
         {
            nspace = 2;
         }
         else
         {
            nspace = 0;
         }
 
         // print one row per line
         for (i = 0; i < LM.M.rows(); i++)
         {
            os << LM.tag << " "; // tag
            if (nspace)
            {
               os << rightJustify(string(" "), nspace); // space
            }
            // print row labels
            if (LM.rc != 2)
            { // but not if 'columns only'
               if (int(pNLrow->getName(i).size()) > LM.wid)
               {
                  s = leftJustify(pNLrow->getName(i), LM.wid);
               }
               else
               {
                  s = rightJustify(pNLrow->getName(i), LM.wid);
               }
               os << s << " "; // label
            }
            // finally, print the data
            jlast = (LM.sym ? i + 1 : LM.M.cols());
            for (j = 0; j < jlast; j++)
            {
               // clean print
               if (LM.cln && ::fabs(LM.M(i, j)) < ::pow(10.0, -LM.prec))
               {
                  os << rightJustify("0", LM.wid);
               }
               else
               {
                  os << setw(LM.wid) << setprecision(LM.prec) << LM.M(i, j);
               }
               if (j < jlast - 1)
               {
                  os << " "; // data
               }
            }
            if (i < LM.M.rows() - 1)
            {
               os << endl;
            }
         }
 
         return os;
      }
      catch (Exception& e)
      {
         GNSSTK_RETHROW(e);
      }
   }
 
} // end namespace gnsstk
 
//------------------------------------------------------------------------------------
//------------------------------------------------------------------------------------