gereon
12 years ago
26 changed files with 704 additions and 141 deletions
-
42CMakeLists.txt
-
56src/exceptions/NoConvergence.h
-
2src/formula/And.h
-
5src/formula/BoundedUntil.h
-
1src/formula/Formulas.h
-
2src/formula/Next.h
-
2src/formula/Not.h
-
2src/formula/Or.h
-
176src/formula/ProbabilisticIntervalOperator.h
-
113src/formula/ProbabilisticOperator.h
-
8src/modelChecker/DtmcPrctlModelChecker.cpp
-
27src/modelChecker/DtmcPrctlModelChecker.h
-
267src/modelChecker/EigenDtmcPrctlModelChecker.h
-
5src/modelChecker/GmmxxDtmcPrctlModelChecker.h
-
30src/models/AtomicPropositionsLabeling.h
-
2src/models/Dtmc.h
-
45src/mrmc.cpp
-
6src/parser/parser.cpp
-
5src/parser/parser.h
-
6src/parser/readLabFile.cpp
-
10src/parser/readTraFile.cpp
-
2src/parser/readTraFile.h
-
5src/storage/BitVector.h
-
4src/storage/SquareSparseMatrix.h
-
13src/utility/osDetection.h
-
9src/utility/vector.h
@ -0,0 +1,56 @@ |
|||
#ifndef MRMC_EXCEPTIONS_NO_CONVERGENCE_H_ |
|||
#define MRMC_EXCEPTIONS_NO_CONVERGENCE_H_ |
|||
|
|||
#include <exception> |
|||
|
|||
namespace mrmc { |
|||
namespace exceptions { |
|||
|
|||
//!This exception is thrown when an iterative solver failed to converge with the given maxIterations |
|||
class NoConvergence : public std::exception |
|||
{ |
|||
public: |
|||
/* The Visual C++-Version of the exception class has constructors accepting |
|||
* a char*-constant; The GCC version does not have these |
|||
* |
|||
* As the "extended" constructor is used in the sparse matrix code, a dummy |
|||
* constructor is used under linux (which will ignore the parameter) |
|||
*/ |
|||
#ifdef _WIN32 |
|||
NoConvergence() : exception("::mrmc::NoConvergence"){ |
|||
iterations = -1; |
|||
maxIterations = -1; |
|||
} |
|||
NoConvergence(const char * const s, int iterations, int maxIterations): exception(s) { |
|||
this->iterations = iterations; |
|||
this->maxIterations = maxIterations; |
|||
} |
|||
#else |
|||
NoConvergence() : exception() { |
|||
iterations = -1; |
|||
maxIterations = -1; |
|||
} |
|||
NoConvergence(const char * const s, int iterations, int maxIterations): exception() { |
|||
this->iterations = iterations; |
|||
this->maxIterations = maxIterations; |
|||
} |
|||
|
|||
#endif |
|||
virtual const char* what() const throw() |
|||
{ return "mrmc::NoConvergence"; } |
|||
|
|||
int getIterationCount() const { |
|||
return iterations; |
|||
} |
|||
int getMaxIterationCount() const { |
|||
return maxIterations; |
|||
} |
|||
private: |
|||
int iterations; |
|||
int maxIterations; |
|||
}; |
|||
|
|||
} // namespace exceptions |
|||
} // namespace mrmc |
|||
|
|||
#endif // MRMC_EXCEPTIONS_NO_CONVERGENCE_H_ |
|||
@ -0,0 +1,176 @@ |
|||
/* |
|||
* ProbabilisticOperator.h |
|||
* |
|||
* Created on: 19.10.2012 |
|||
* Author: Thomas Heinemann |
|||
*/ |
|||
|
|||
#ifndef PROBABILISTICINTERVALOPERATOR_H_ |
|||
#define PROBABILISTICINTERVALOPERATOR_H_ |
|||
|
|||
#include "PCTLStateFormula.h" |
|||
#include "PCTLPathFormula.h" |
|||
#include "utility/const_templates.h" |
|||
|
|||
namespace mrmc { |
|||
|
|||
namespace formula { |
|||
|
|||
/*! |
|||
* @brief |
|||
* Class for a PCTL formula tree with a P (probablistic) operator node over a probability interval |
|||
* as root. |
|||
* |
|||
* If the probability interval consist just of one single value (i.e. it is [x,x] for some |
|||
* real number x), the class ProbabilisticOperator should be used instead. |
|||
* |
|||
* |
|||
* Has one PCTL path formula as sub formula/tree. |
|||
* |
|||
* @par Semantics |
|||
* The formula holds iff the probability that the path formula holds is inside the bounds |
|||
* specified in this operator |
|||
* |
|||
* The subtree is seen as part of the object and deleted with it |
|||
* (this behavior can be prevented by setting them to NULL before deletion) |
|||
* |
|||
* |
|||
* @see PCTLStateFormula |
|||
* @see PCTLPathFormula |
|||
* @see ProbabilisticOperator |
|||
* @see PCTLFormula |
|||
*/ |
|||
template<class T> |
|||
class ProbabilisticIntervalOperator : public PCTLStateFormula<T> { |
|||
|
|||
public: |
|||
/*! |
|||
* Empty constructor |
|||
*/ |
|||
ProbabilisticIntervalOperator() { |
|||
upper = mrmc::utility::constGetZero(upper); |
|||
lower = mrmc::utility::constGetZero(lower); |
|||
pathFormula = NULL; |
|||
} |
|||
|
|||
/*! |
|||
* Constructor |
|||
* |
|||
* @param lowerBound The lower bound for the probability |
|||
* @param upperBound The upper bound for the probability |
|||
* @param pathFormula The child node |
|||
*/ |
|||
ProbabilisticIntervalOperator(T lowerBound, T upperBound, PCTLPathFormula<T>& pathFormula) { |
|||
this->lower = lowerBound; |
|||
this->upper = upperBound; |
|||
this->pathFormula = &pathFormula; |
|||
} |
|||
|
|||
/*! |
|||
* Destructor |
|||
* |
|||
* The subtree is deleted with the object |
|||
* (this behavior can be prevented by setting them to NULL before deletion) |
|||
*/ |
|||
virtual ~ProbabilisticIntervalOperator() { |
|||
if (pathFormula != NULL) { |
|||
delete pathFormula; |
|||
} |
|||
} |
|||
|
|||
/*! |
|||
* @returns the child node (representation of a PCTL path formula) |
|||
*/ |
|||
const PCTLPathFormula<T>& getPathFormula () const { |
|||
return *pathFormula; |
|||
} |
|||
|
|||
/*! |
|||
* @returns the lower bound for the probability |
|||
*/ |
|||
const T& getLowerBound() const { |
|||
return lower; |
|||
} |
|||
|
|||
/*! |
|||
* @returns the upper bound for the probability |
|||
*/ |
|||
const T& getUpperBound() const { |
|||
return upper; |
|||
} |
|||
|
|||
/*! |
|||
* Sets the child node |
|||
* |
|||
* @param pathFormula the path formula that becomes the new child node |
|||
*/ |
|||
void setPathFormula(PCTLPathFormula<T>* pathFormula) { |
|||
this->pathFormula = pathFormula; |
|||
} |
|||
|
|||
/*! |
|||
* Sets the interval in which the probability that the path formula holds may lie in. |
|||
* |
|||
* @param lowerBound The lower bound for the probability |
|||
* @param upperBound The upper bound for the probability |
|||
*/ |
|||
void setInterval(T lowerBound, T upperBound) { |
|||
this->lower = lowerBound; |
|||
this->upper = upperBound; |
|||
} |
|||
|
|||
/*! |
|||
* @returns a string representation of the formula |
|||
*/ |
|||
virtual std::string toString() const { |
|||
std::string result = "("; |
|||
result += " P["; |
|||
result += std::to_string(lower); |
|||
result += ";"; |
|||
result += std::to_string(upper); |
|||
result += "] "; |
|||
result += pathFormula->toString(); |
|||
result += ")"; |
|||
return result; |
|||
} |
|||
|
|||
/*! |
|||
* Clones the called object. |
|||
* |
|||
* Performs a "deep copy", i.e. the subtrees of the new object are clones of the original ones |
|||
* |
|||
* @returns a new AND-object that is identical the called object. |
|||
*/ |
|||
virtual PCTLStateFormula<T>* clone() const { |
|||
ProbabilisticIntervalOperator<T>* result = new ProbabilisticIntervalOperator<T>(); |
|||
result->setInterval(lower, upper); |
|||
if (pathFormula != NULL) { |
|||
result->setPathFormula(pathFormula->clone()); |
|||
} |
|||
return result; |
|||
} |
|||
|
|||
/*! |
|||
* Calls the model checker to check this formula. |
|||
* Needed to infer the correct type of formula class. |
|||
* |
|||
* @note This function should only be called in a generic check function of a model checker class. For other uses, |
|||
* the methods of the model checker should be used. |
|||
* |
|||
* @returns A bit vector indicating all states that satisfy the formula represented by the called object. |
|||
*/ |
|||
virtual mrmc::storage::BitVector *check(const mrmc::modelChecker::DtmcPrctlModelChecker<T>& modelChecker) const { |
|||
return modelChecker.checkProbabilisticIntervalOperator(*this); |
|||
} |
|||
|
|||
private: |
|||
T lower; |
|||
T upper; |
|||
PCTLPathFormula<T>* pathFormula; |
|||
}; |
|||
|
|||
} //namespace formula |
|||
|
|||
} //namespace mrmc |
|||
|
|||
#endif /* PROBABILISTICINTERVALOPERATOR_H_ */ |
|||
@ -1,8 +0,0 @@ |
|||
/*
|
|||
* DtmcPrctlModelChecker.cpp |
|||
* |
|||
* Created on: 22.10.2012 |
|||
* Author: Thomas Heinemann |
|||
*/ |
|||
|
|||
#include "DtmcPrctlModelChecker.h"
|
|||
@ -0,0 +1,267 @@ |
|||
/* |
|||
* EigenDtmcPrctlModelChecker.h |
|||
* |
|||
* Created on: 07.12.2012 |
|||
* Author: |
|||
*/ |
|||
|
|||
#ifndef EIGENDTMCPRCTLMODELCHECKER_H_ |
|||
#define EIGENDTMCPRCTLMODELCHECKER_H_ |
|||
|
|||
#include "src/utility/vector.h" |
|||
|
|||
#include "src/models/Dtmc.h" |
|||
#include "src/modelChecker/DtmcPrctlModelChecker.h" |
|||
#include "src/solver/GraphAnalyzer.h" |
|||
#include "src/utility/const_templates.h" |
|||
#include "src/exceptions/NoConvergence.h" |
|||
|
|||
#include "Eigen/Sparse" |
|||
#include "Eigen/src/IterativeLinearSolvers/BiCGSTAB.h" |
|||
|
|||
#include "gmm/gmm_matrix.h" |
|||
#include "gmm/gmm_iter_solvers.h" |
|||
|
|||
#include "log4cplus/logger.h" |
|||
#include "log4cplus/loggingmacros.h" |
|||
|
|||
extern log4cplus::Logger logger; |
|||
|
|||
namespace mrmc { |
|||
|
|||
namespace modelChecker { |
|||
|
|||
/* |
|||
* A model checking engine that makes use of the eigen backend. |
|||
*/ |
|||
template <class Type> |
|||
class EigenDtmcPrctlModelChecker : public DtmcPrctlModelChecker<Type> { |
|||
|
|||
public: |
|||
explicit EigenDtmcPrctlModelChecker(mrmc::models::Dtmc<Type>& dtmc) : DtmcPrctlModelChecker<Type>(dtmc) { } |
|||
|
|||
virtual ~EigenDtmcPrctlModelChecker() { } |
|||
|
|||
virtual mrmc::storage::BitVector* checkProbabilisticOperator(const mrmc::formula::ProbabilisticOperator<Type>& formula) const { |
|||
std::vector<Type>* probabilisticResult = this->checkPathFormula(formula.getPathFormula()); |
|||
|
|||
mrmc::storage::BitVector* result = new mrmc::storage::BitVector(this->getModel().getNumberOfStates()); |
|||
Type bound = formula.getBound(); |
|||
for (uint_fast64_t i = 0; i < this->getModel().getNumberOfStates(); ++i) { |
|||
if ((*probabilisticResult)[i] == bound) result->set(i, true); |
|||
} |
|||
|
|||
delete probabilisticResult; |
|||
|
|||
return result; |
|||
} |
|||
|
|||
virtual mrmc::storage::BitVector* checkProbabilisticIntervalOperator(const mrmc::formula::ProbabilisticIntervalOperator<Type>& formula) const { |
|||
std::vector<Type>* probabilisticResult = this->checkPathFormula(formula.getPathFormula()); |
|||
|
|||
mrmc::storage::BitVector* result = new mrmc::storage::BitVector(this->getModel().getNumberOfStates()); |
|||
Type lower = formula.getLowerBound(); |
|||
Type upper = formula.getUpperBound(); |
|||
for (uint_fast64_t i = 0; i < this->getModel().getNumberOfStates(); ++i) { |
|||
if ((*probabilisticResult)[i] >= lower && (*probabilisticResult)[i] <= upper) result->set(i, true); |
|||
} |
|||
|
|||
delete probabilisticResult; |
|||
|
|||
return result; |
|||
} |
|||
|
|||
virtual std::vector<Type>* checkBoundedUntil(const mrmc::formula::BoundedUntil<Type>& formula) const { |
|||
// First, we need to compute the states that satisfy the sub-formulas of the until-formula. |
|||
mrmc::storage::BitVector* leftStates = this->checkStateFormula(formula.getLeft()); |
|||
mrmc::storage::BitVector* rightStates = this->checkStateFormula(formula.getRight()); |
|||
|
|||
// Copy the matrix before we make any changes. |
|||
mrmc::storage::SquareSparseMatrix<Type> tmpMatrix(*this->getModel().getTransitionProbabilityMatrix()); |
|||
|
|||
// Make all rows absorbing that violate both sub-formulas or satisfy the second sub-formula. |
|||
tmpMatrix.makeRowsAbsorbing((~*leftStates & *rightStates) | *rightStates); |
|||
|
|||
// Transform the transition probability matrix to the eigen format to use its arithmetic. |
|||
Eigen::SparseMatrix<Type, 1, int_fast32_t>* eigenMatrix = tmpMatrix.toEigenSparseMatrix(); |
|||
|
|||
// Create the vector with which to multiply. |
|||
uint_fast64_t stateCount = this->getModel().getNumberOfStates(); |
|||
|
|||
typedef Eigen::Matrix<Type, -1, 1, 0, -1, 1> VectorType; |
|||
typedef Eigen::Map<VectorType> MapType; |
|||
|
|||
std::vector<Type>* result = new std::vector<Type>(stateCount); |
|||
|
|||
// Dummy Type variable for const templates |
|||
Type dummy; |
|||
mrmc::utility::setVectorValues(result, *rightStates, mrmc::utility::constGetOne(dummy)); |
|||
|
|||
Type *p = &((*result)[0]); // get the address storing the data for result |
|||
MapType vectorMap(p, result->size()); // vectorMap shares data |
|||
|
|||
|
|||
// Now perform matrix-vector multiplication as long as we meet the bound of the formula. |
|||
for (uint_fast64_t i = 0, bound = formula.getBound(); i < bound; ++i) { |
|||
vectorMap = (*eigenMatrix) * vectorMap; |
|||
} |
|||
|
|||
// Delete intermediate results. |
|||
delete leftStates; |
|||
delete rightStates; |
|||
delete eigenMatrix; |
|||
|
|||
return result; |
|||
} |
|||
|
|||
virtual std::vector<Type>* checkNext(const mrmc::formula::Next<Type>& formula) const { |
|||
// First, we need to compute the states that satisfy the sub-formula of the next-formula. |
|||
mrmc::storage::BitVector* nextStates = this->checkStateFormula(formula.getChild()); |
|||
|
|||
// Transform the transition probability matrix to the gmm++ format to use its arithmetic. |
|||
Eigen::SparseMatrix<Type, 1, int_fast32_t>* eigenMatrix = this->getModel().getTransitionProbabilityMatrix()->toEigenSparseMatrix(); |
|||
|
|||
// Create the vector with which to multiply and initialize it correctly. |
|||
std::vector<Type> x(this->getModel().getNumberOfStates()); |
|||
Type dummy; |
|||
mrmc::utility::setVectorValues(&x, *nextStates, mrmc::utility::constGetOne(dummy)); |
|||
|
|||
// Delete not needed next states bit vector. |
|||
delete nextStates; |
|||
|
|||
typedef Eigen::Matrix<Type, -1, 1, 0, -1, 1> VectorType; |
|||
typedef Eigen::Map<VectorType> MapType; |
|||
|
|||
Type *px = &(x[0]); // get the address storing the data for x |
|||
MapType vectorX(px, x.size()); // vectorX shares data |
|||
|
|||
// Create resulting vector. |
|||
std::vector<Type>* result = new std::vector<Type>(this->getModel().getNumberOfStates()); |
|||
|
|||
Type *pr = &((*result)[0]); // get the address storing the data for result |
|||
MapType vectorResult(px, result->size()); // vectorResult shares data |
|||
|
|||
// Perform the actual computation. |
|||
vectorResult = (*eigenMatrix) * vectorX; |
|||
|
|||
// Delete temporary matrix and return result. |
|||
delete eigenMatrix; |
|||
return result; |
|||
} |
|||
|
|||
virtual std::vector<Type>* checkUntil(const mrmc::formula::Until<Type>& formula) const { |
|||
// First, we need to compute the states that satisfy the sub-formulas of the until-formula. |
|||
mrmc::storage::BitVector* leftStates = this->checkStateFormula(formula.getLeft()); |
|||
mrmc::storage::BitVector* rightStates = this->checkStateFormula(formula.getRight()); |
|||
|
|||
// Then, we need to identify the states which have to be taken out of the matrix, i.e. |
|||
// all states that have probability 0 and 1 of satisfying the until-formula. |
|||
mrmc::storage::BitVector notExistsPhiUntilPsiStates(this->getModel().getNumberOfStates()); |
|||
mrmc::storage::BitVector alwaysPhiUntilPsiStates(this->getModel().getNumberOfStates()); |
|||
mrmc::solver::GraphAnalyzer::getPhiUntilPsiStates<double>(this->getModel(), *leftStates, *rightStates, ¬ExistsPhiUntilPsiStates, &alwaysPhiUntilPsiStates); |
|||
notExistsPhiUntilPsiStates.complement(); |
|||
|
|||
delete leftStates; |
|||
delete rightStates; |
|||
|
|||
LOG4CPLUS_INFO(logger, "Found " << notExistsPhiUntilPsiStates.getNumberOfSetBits() << " 'no' states."); |
|||
LOG4CPLUS_INFO(logger, "Found " << alwaysPhiUntilPsiStates.getNumberOfSetBits() << " 'yes' states."); |
|||
mrmc::storage::BitVector maybeStates = ~(notExistsPhiUntilPsiStates | alwaysPhiUntilPsiStates); |
|||
LOG4CPLUS_INFO(logger, "Found " << maybeStates.getNumberOfSetBits() << " 'maybe' states."); |
|||
|
|||
// Create resulting vector and set values accordingly. |
|||
uint_fast64_t stateCount = this->getModel().getNumberOfStates(); |
|||
std::vector<Type>* result = new std::vector<Type>(stateCount); |
|||
|
|||
// Only try to solve system if there are states for which the probability is unknown. |
|||
if (maybeStates.getNumberOfSetBits() > 0) { |
|||
typedef Eigen::Matrix<Type, -1, 1, 0, -1, 1> VectorType; |
|||
typedef Eigen::Map<VectorType> MapType; |
|||
|
|||
// Now we can eliminate the rows and columns from the original transition probability matrix. |
|||
mrmc::storage::SquareSparseMatrix<double>* submatrix = this->getModel().getTransitionProbabilityMatrix()->getSubmatrix(maybeStates); |
|||
// Converting the matrix to the form needed for the equation system. That is, we go from |
|||
// x = A*x + b to (I-A)x = b. |
|||
submatrix->convertToEquationSystem(); |
|||
|
|||
// Transform the submatric matrix to the eigen format to use its solvers |
|||
Eigen::SparseMatrix<Type, 1, int_fast32_t>* eigenSubMatrix = submatrix->toEigenSparseMatrix(); |
|||
|
|||
// Initialize the x vector with 0.5 for each element. This is the initial guess for |
|||
// the iterative solvers. It should be safe as for all 'maybe' states we know that the |
|||
// probability is strictly larger than 0. |
|||
std::vector<Type> x(maybeStates.getNumberOfSetBits(), Type(0.5)); |
|||
|
|||
// Map for x |
|||
Type *px = &(x[0]); // get the address storing the data for x |
|||
MapType vectorX(px, x.size()); // vectorX shares data |
|||
|
|||
|
|||
// Prepare the right-hand side of the equation system. For entry i this corresponds to |
|||
// the accumulated probability of going from state i to some 'yes' state. |
|||
std::vector<double> b(maybeStates.getNumberOfSetBits()); |
|||
|
|||
Type *pb = &(b[0]); // get the address storing the data for b |
|||
MapType vectorB(pb, b.size()); // vectorB shares data |
|||
|
|||
this->getModel().getTransitionProbabilityMatrix()->getConstrainedRowCountVector(maybeStates, alwaysPhiUntilPsiStates, &x); |
|||
|
|||
Eigen::BiCGSTAB<Eigen::SparseMatrix<Type, 1, int_fast32_t>> solver; |
|||
solver.compute(*eigenSubMatrix); |
|||
if(solver.info()!= Eigen::ComputationInfo::Success) { |
|||
// decomposition failed |
|||
LOG4CPLUS_ERROR(logger, "Decomposition of Submatrix failed!"); |
|||
} |
|||
|
|||
// Now do the actual solving. |
|||
LOG4CPLUS_INFO(logger, "Starting iterative solver."); |
|||
|
|||
solver.setTolerance(0.000001); |
|||
|
|||
bool hasConverged = false; |
|||
int turns = 6; |
|||
while (!hasConverged) { |
|||
vectorX = solver.solve(vectorB); |
|||
hasConverged = (solver.info() != Eigen::ComputationInfo::NoConvergence) || (turns <= 0); |
|||
if (!hasConverged) { |
|||
LOG4CPLUS_INFO(logger, "EigenDtmcPrctlModelChecker did not converge with " << solver.iterations() << " of max. " << solver.maxIterations() << "Iterations, restarting "); |
|||
solver.setMaxIterations(solver.maxIterations() * 2); |
|||
} |
|||
--turns; |
|||
} |
|||
|
|||
if(solver.info() == Eigen::ComputationInfo::InvalidInput) { |
|||
// solving failed |
|||
LOG4CPLUS_ERROR(logger, "Solving of Submatrix failed: InvalidInput"); |
|||
} else if(solver.info() == Eigen::ComputationInfo::NoConvergence) { |
|||
// NoConvergence |
|||
throw mrmc::exceptions::NoConvergence("Solving of Submatrix with Eigen failed", solver.iterations(), solver.maxIterations()); |
|||
} else if(solver.info() == Eigen::ComputationInfo::NumericalIssue) { |
|||
// NumericalIssue |
|||
LOG4CPLUS_ERROR(logger, "Solving of Submatrix failed: NumericalIssue"); |
|||
} else if(solver.info() == Eigen::ComputationInfo::Success) { |
|||
// solving Success |
|||
LOG4CPLUS_INFO(logger, "Solving of Submatrix succeeded: Success"); |
|||
} |
|||
|
|||
// Set values of resulting vector according to result. |
|||
mrmc::utility::setVectorValues<Type>(result, maybeStates, x); |
|||
|
|||
// Delete temporary matrix. |
|||
delete eigenSubMatrix; |
|||
} |
|||
|
|||
// Dummy Type variable for const templates |
|||
Type dummy; |
|||
mrmc::utility::setVectorValues<Type>(result, notExistsPhiUntilPsiStates, mrmc::utility::constGetZero(dummy)); |
|||
mrmc::utility::setVectorValues<Type>(result, alwaysPhiUntilPsiStates, mrmc::utility::constGetOne(dummy)); |
|||
|
|||
return result; |
|||
} |
|||
}; |
|||
|
|||
} //namespace modelChecker |
|||
|
|||
} //namespace mrmc |
|||
|
|||
#endif /* EIGENDTMCPRCTLMODELCHECKER_H_ */ |
|||
@ -1,12 +1,15 @@ |
|||
#pragma once |
|||
|
|||
#if defined __linux__ || defined __linux |
|||
#define LINUX |
|||
# define LINUX |
|||
#elif defined TARGET_OS_MAC || defined __apple__ || defined __APPLE__ |
|||
#define MACOSX |
|||
#define _DARWIN_USE_64_BIT_INODE |
|||
# define MACOSX |
|||
# define _DARWIN_USE_64_BIT_INODE |
|||
#elif defined _WIN32 || defined _WIN64 |
|||
#define WINDOWS |
|||
# define WINDOWS |
|||
# define NOMINMAX |
|||
# include <Windows.h> |
|||
# include <winnt.h> |
|||
#else |
|||
#error Could not detect Operating System |
|||
# error Could not detect Operating System |
|||
#endif |
|||
Write
Preview
Loading…
Cancel
Save
Reference in new issue