src/TransformConstantsClassesAndFunctions.hpp

Go to the documentation of this file.

#ifndef _TransformConstantsClassesAndFunctions_HPP_
#define _TransformConstantsClassesAndFunctions_HPP_

#include <cmath>
#include <string>
#include <vector>
#include <iomanip>

#include <xercesc/util/PlatformUtils.hpp>


const std::string INPUT_FILE_FILENAME_EXTENSION_TSP = ".tsp";

const std::string INPUT_FILE_FILENAME_EXTENSION_ATSP = ".atsp";

const std::string TAG_NAME = "NAME:";

const std::string TAG_TYPE = "TYPE:";

const std::string TAG_COMMENT = "COMMENT:";

const std::string TAG_DIMENSION = "DIMENSION:";

const std::string TAG_EDGE_WEIGHT_TYPE = "EDGE_WEIGHT_TYPE:";

const std::string TAG_EDGE_WEIGHT_FORMAT = "EDGE_WEIGHT_FORMAT:";

const std::string TAG_DISPLAY_DATA_TYPE = "DISPLAY_DATA_TYPE:";

const std::string TAG_NODE_COORD_SECTION = "NODE_COORD_SECTION";

const std::string EDGE_WEIGHT_SECTION = "EDGE_WEIGHT_SECTION";

const std::string DISPLAY_DATA_SECTION = "DISPLAY_DATA_SECTION";

const std::string TAG_EOF = "EOF";

const std::string VALUE_TYPE_TSP = "TSP";

const std::string VALUE_TYPE_ATSP = "ATSP";

const double RRR = 6378.388;

const std::string VALUE_EDGE_WEIGHT_TYPE_GEO = "GEO";

const std::string VALUE_EDGE_WEIGHT_TYPE_EUC_2D = "EUC_2D";

const std::string VALUE_EDGE_WEIGHT_TYPE_CEIL_2D = "CEIL_2D";

const std::string VALUE_EDGE_WEIGHT_TYPE_ATT = "ATT";

const std::string VALUE_EDGE_WEIGHT_TYPE_EXPLICIT = "EXPLICIT";

const std::string VALUE_EDGE_WEIGHT_FORMAT_FUNCTION = "FUNCTION";

const std::string VALUE_EDGE_WEIGHT_FORMAT_FULL_MATRIX = "FULL_MATRIX";

const std::string VALUE_EDGE_WEIGHT_FORMAT_LOWER_DIAG_ROW = "LOWER_DIAG_ROW";

const std::string VALUE_EDGE_WEIGHT_FORMAT_UPPER_DIAG_ROW = "UPPER_DIAG_ROW";

const std::string VALUE_EDGE_WEIGHT_FORMAT_UPPER_ROW = "UPPER_ROW";

const std::string VALUE_DISPLAY_DATA_TYPE_COORD_DISPLAY = "COORD_DISPLAY";

const std::string VALUE_DISPLAY_DATA_TYPE_TWOD_DISPLAY = "TWOD_DISPLAY";


const std::string OUTPUT_FILE_FILENAME_EXTENSION = ".xml";

const bool XML_FORMAT_PRETTY_PRINT = true;

const std::string XML_DOCUMENT_NODE = "travellingSalesmanProblemInstance";

const std::string XML_NAME = "name";

const std::string XML_SOURCE = "source";

const std::string XML_DESCRIPTION = "description";

const std::string XML_DOUBLE_PRECISION = "doublePrecision";

const std::string XML_IGNORED_DIGITS = "ignoredDigits";

const std::string XML_GRAPH = "graph";

const std::string XML_VERTEX = "vertex";

const std::string XML_EDGE = "edge";

const std::string XML_EDGE_ATTRIBUTE_COST = "cost";

const std::string XML_ENCODING = "UTF-8";

const std::string XML_VALUE_SOURCE_TSPLIB = "TSPLIB";

const std::ios::fmtflags DOUBLE_FLOATFIELD = std::ios::scientific;

const std::streamsize TRANSFORM_DOUBLE_PRECISION = std::numeric_limits<double>::digits10;

const std::streamsize TRANSFORM_IGNORED_DIGITS = 5;

const double TRANSFORM_DOUBLE_ZERO =
                pow(10.0, -1.0 * static_cast<double>(TRANSFORM_DOUBLE_PRECISION - TRANSFORM_IGNORED_DIGITS));


inline void trimLeft (std::string &s, const std::string &t = " \t\r\n") {
        s.erase(0, s.find_first_not_of(t));
}

inline void trimRight (std::string &s, const std::string &t = " \t\r\n") {
        std::string::size_type i = s.find_last_not_of(t);
        if (i == std::string::npos) {
                s = "";
        }
        else {
                s.erase(s.find_last_not_of(t) + 1);
        }
}

inline void trim (std::string &s, const std::string &t = " \t\r\n") {
        trimLeft(s, t);
        trimRight(s, t);
}

inline double roundToDoublePrecisionAndDoubleFloatField(double d) {
        std::stringstream dStringstream;
        dStringstream.setf(DOUBLE_FLOATFIELD, std::ios::floatfield);
        dStringstream << std::setprecision(static_cast<int>(TRANSFORM_DOUBLE_PRECISION));
        dStringstream << d;
        std::string dString;
        dString = dStringstream.str();
        std::istringstream dIstringstream(dString);
        double result;
        dIstringstream >> result;
        return (result);
}


class InputFileFormatNotSupported : public std::exception {
public:
        inline InputFileFormatNotSupported() {
        }
};

class TransformInstance {
private:
        std::string type;

        std::string name;

        std::string source;

        std::string description;

        std::vector<std::vector<double> >::size_type n;

        std::vector<std::vector<double> > adjacencyMatrix;

        void init(
                        const std::string &type,
                        const std::string &name,
                        const std::string &source,
                        const std::string &description,
                        const std::vector<std::vector<double> >::size_type n);

public:
        TransformInstance(
                        const std::string &type,
                        const std::string &name,
                        const std::string &source,
                        const std::string &description,
                        const std::vector<std::vector<double> >::size_type n);

        TransformInstance(const TransformInstance &transformInstance);

        TransformInstance &operator=(const TransformInstance &transformInstance);

        inline std::string getType() const {
                return (type);
        }

        inline std::string getName() const {
                return (name);
        }

        inline std::string getSource() const {
                return (source);
        }

        inline std::string getDescription() const {
                return (description);
        }

        inline std::vector<std::vector<double> >::size_type getN() const {
                return (n);
        }

        inline void setAdjacencyMatrixElement(
                        const std::vector<std::vector<double> >::size_type i,
                        const std::vector<double>::size_type j,
                        const double value) {
                double roundedValue = roundToDoublePrecisionAndDoubleFloatField(value);
                if (type == VALUE_TYPE_TSP) {
                        if (i < j) {
                                adjacencyMatrix.at(
                                                static_cast<std::vector<std::vector<double> >::size_type>(j)).at(
                                                                static_cast<std::vector<double>::size_type>(i)) = roundedValue;
                        }
                        else {
                                adjacencyMatrix.at(i).at(j) = roundedValue;
                        }
                }
                else {  //if (type == VALUE_TYPE_ATSP)
                        adjacencyMatrix.at(i).at(j) = roundedValue;
                }
        }

        inline double getAdjacencyMatrixElement(
                        const std::vector<std::vector<double> >::size_type i,
                        const std::vector<double>::size_type j) const {
                if (type == VALUE_TYPE_TSP) {
                        if (i < j) {
                                return (adjacencyMatrix.at(
                                                static_cast<std::vector<std::vector<double> >::size_type>(j)).at(
                                                                static_cast<std::vector<double>::size_type>(i)));
                        }
                        else {
                                return (adjacencyMatrix.at(i).at(j));
                        }
                }
                else {  //if (type == VALUE_TYPE_ATSP)
                        return (adjacencyMatrix.at(i).at(j));
                }
        }
};


TransformInstance *readInputFileTSPLIB(const std::string &inputFileName);

void writeOutputFile(const std::string &outputFileName, const TransformInstance *transformInstance);

void writeOutputFileWithoutUsingAParser(
                const std::string &outputFileName,
                const TransformInstance *transformInstance);


#endif