fuzzylite.h

Go to the documentation of this file.

/*
 fuzzylite (R), a fuzzy logic control library in C++.
 Copyright (C) 2010-2016 FuzzyLite Limited. All rights reserved.
 Author: Juan Rada-Vilela, Ph.D. <jcrada@fuzzylite.com>

 This file is part of fuzzylite.

 fuzzylite is free software: you can redistribute it and/or modify it under
 the terms of the FuzzyLite License included with the software.

 You should have received a copy of the FuzzyLite License along with
 fuzzylite. If not, see <http://www.fuzzylite.com/license/>.

 fuzzylite is a registered trademark of FuzzyLite Limited.
 */

#ifndef FL_FUZZYLITE_H
#define FL_FUZZYLITE_H

#include <algorithm>
#include <cmath>
#include <iostream>
#include <sstream>
#include <limits>
#include <memory>
#include <cstddef>

#ifndef FL_BUILD_PATH
#define FL_BUILD_PATH ""
#endif

#if defined(_WIN32) || defined(WIN32)
#define FL_WINDOWS
#endif

#if defined(unix) || defined(__unix__) || defined(__unix)
#define FL_UNIX
#endif

#ifdef __APPLE__
#define FL_APPLE
#ifndef FL_UNIX
#define FL_UNIX
#endif
#endif

#define FL__FILE__ std::string(__FILE__).substr(std::string(FL_BUILD_PATH).size())

#define FL_LOG_PREFIX FL__FILE__ << " (" << __LINE__ << "):"

#define FL_AT FL__FILE__, __LINE__, __FUNCTION__

#define FL_LOG(message) {if (fl::fuzzylite::isLogging()){std::cout << FL_LOG_PREFIX << message << std::endl;}}
#define FL_LOGP(message) {if (fl::fuzzylite::isLogging()){std::cout << message << std::endl;}}

#define FL_DEBUG_BEGIN if (fl::fuzzylite::isDebugging()){
#define FL_DEBUG_END }

#define FL_DBG(message) FL_DEBUG_BEGIN\
        std::cout << FL__FILE__ << "::" << __FUNCTION__ << "[" << __LINE__ << "]:" \
                << message << std::endl;\
        FL_DEBUG_END


#ifdef FL_WINDOWS
#include <ciso646> //alternative operator spellings:
//#define and &&
//#define or ||
//#define not !
//#define bitand &
//#define bitor |

//@todo: Address warning 4251 by exporting members?
//http://www.unknownroad.com/rtfm/VisualStudio/warningC4251.html
#ifdef _MSC_VER
#pragma warning (disable:4251)
#endif

//fuzzylite as a shared library is exported
//Applications linking with fuzzylite as a shared library need to import

//fuzzylite as a static library does not export or import
//Applications linking with fuzzylite as a static library do not import

#if defined(FL_EXPORT_LIBRARY)
#define FL_API __declspec(dllexport)
#elif defined(FL_IMPORT_LIBRARY)
#define FL_API __declspec(dllimport)
#else
#define FL_API
#endif

#else
#define FL_API
#endif

namespace fl {
#ifdef FL_USE_FLOAT
    typedef float scalar;
#else

    typedef double scalar;
#endif

#define FL_IUNUSED(x) (void) (x)

#ifdef __GNUC__
#define FL_IUNUSED_DECL __attribute__((unused))
#else
#define FL_IUNUSED_DECL
#endif

    const scalar nan FL_IUNUSED_DECL = std::numeric_limits<scalar>::quiet_NaN();
    const scalar inf FL_IUNUSED_DECL = std::numeric_limits<scalar>::infinity();

#ifdef FL_CPP98
    //C++98 defines

    //Pointers
    const long null = 0L;
#define FL_unique_ptr std::auto_ptr
#define FL_move_ptr(x) x

    //Identifiers
#define FL_IOVERRIDE
#define FL_IFINAL
#define FL_IDEFAULT
#define FL_IDELETE
#define FL_INOEXCEPT throw()
#define FL_ITHREAD_LOCAL

    //Constructors
#define FL_DEFAULT_COPY(Class)
#define FL_DEFAULT_MOVE(Class)
#define FL_DEFAULT_COPY_AND_MOVE(Class)

#define FL_DISABLE_COPY(Class) \
    Class(const Class &);\
    Class &operator=(const Class &);

#else
    //C++11 defines

    //Pointers
    const std::nullptr_t null = nullptr;
#define FL_unique_ptr std::unique_ptr
#define FL_move_ptr(x) std::move(x)

    //Identifiers
#define FL_IOVERRIDE override
#define FL_IFINAL final
#define FL_IDEFAULT = default
#define FL_IDELETE = delete
#define FL_INOEXCEPT noexcept
#define FL_ITHREAD_LOCAL /*thread_local (commented for performance)*/

    //Constructors
#define FL_DEFAULT_COPY(Class) \
    Class(const Class&) = default; \
    Class& operator=(const Class&) = default;
#define FL_DEFAULT_MOVE(Class) \
    Class(Class&&) = default; \
    Class& operator=(Class&&) = default;
#define FL_DEFAULT_COPY_AND_MOVE(Class) \
    Class(const Class&) = default; \
    Class& operator=(const Class&) = default;\
    Class(Class&&) = default; \
    Class& operator=(Class&&) = default;

#define FL_DISABLE_COPY(Class) \
    Class(const Class &) = delete;\
    Class &operator=(const Class &) = delete;

#endif

}


namespace fl {

    class FL_API fuzzylite {
        friend class Operation;
    private:
        static int _decimals;
        static scalar _macheps;
        static std::ios_base::fmtflags _scalarFormat;
        static bool _logging;
        static bool _debugging;
    public:
        static std::string name();
        static std::string version();
        static std::string library();

        static std::string license();

        static std::string author();

        static std::string company();

        static std::string website();

        static int decimals();

        static void setDecimals(int decimals);

        static scalar macheps();

        static void setMachEps(scalar macheps);

        static void setScalarFormat(std::ios_base::fmtflags scalarFormat);

        static std::ios_base::fmtflags scalarFormat();

        static bool isLogging();

        static void setLogging(bool logging);

        static bool isDebugging();

        static void setDebugging(bool debugging);

        static std::string platform();

        static std::string floatingPoint();
    };
}


namespace fl {

    inline std::string fuzzylite::name() {
        return "fuzzylite";
    }

    inline std::string fuzzylite::library() {
        return name() + " " + version();
    }

    inline std::string fuzzylite::version() {
        return "6.0";
    }

    inline std::string fuzzylite::license() {
        return "FuzzyLite License";
    }

    inline std::string fuzzylite::author() {
        return "Juan Rada-Vilela, Ph.D.";
    }

    inline std::string fuzzylite::company() {
        return "FuzzyLite Limited";
    }

    inline std::string fuzzylite::website() {
        return "http://www.fuzzylite.com/";
    }

    inline void fuzzylite::setDebugging(bool debugging) {
        _debugging = debugging;
    }

    inline bool fuzzylite::isDebugging() {
        return _debugging;
    }

    inline void fuzzylite::setDecimals(int decimals) {
        _decimals = decimals;
    }

    inline int fuzzylite::decimals() {
        return _decimals;
    }

    inline void fuzzylite::setScalarFormat(std::ios_base::fmtflags scalarFormat) {
        _scalarFormat = scalarFormat;
    }

    inline std::ios_base::fmtflags fuzzylite::scalarFormat() {
        return _scalarFormat;
    }

    inline void fuzzylite::setMachEps(scalar macheps) {
        _macheps = macheps;
    }

    inline scalar fuzzylite::macheps() {
        return _macheps;
    }

    inline void fuzzylite::setLogging(bool logging) {
        _logging = logging;
    }

    inline bool fuzzylite::isLogging() {
        return _logging;
    }
}

#endif  /* FL_FUZZYLITE_H */