diff --git a/thirdparty/include/Lua/lauxlib.h b/thirdparty/include/Lua/lauxlib.h deleted file mode 100644 index 0bac2467e..000000000 --- a/thirdparty/include/Lua/lauxlib.h +++ /dev/null @@ -1,256 +0,0 @@ -/* -** $Id: lauxlib.h,v 1.128 2014/10/29 16:11:17 roberto Exp $ -** Auxiliary functions for building Lua libraries -** See Copyright Notice in lua.h -*/ - - -#ifndef lauxlib_h -#define lauxlib_h - - -#include -#include - -#include "lua.h" - - - -/* extra error code for 'luaL_load' */ -#define LUA_ERRFILE (LUA_ERRERR+1) - - -typedef struct luaL_Reg { - const char *name; - lua_CFunction func; -} luaL_Reg; - - -#define LUAL_NUMSIZES (sizeof(lua_Integer)*16 + sizeof(lua_Number)) - -LUALIB_API void (luaL_checkversion_) (lua_State *L, lua_Number ver, size_t sz); -#define luaL_checkversion(L) \ - luaL_checkversion_(L, LUA_VERSION_NUM, LUAL_NUMSIZES) - -LUALIB_API int (luaL_getmetafield) (lua_State *L, int obj, const char *e); -LUALIB_API int (luaL_callmeta) (lua_State *L, int obj, const char *e); -LUALIB_API const char *(luaL_tolstring) (lua_State *L, int idx, size_t *len); -LUALIB_API int (luaL_argerror) (lua_State *L, int arg, const char *extramsg); -LUALIB_API const char *(luaL_checklstring) (lua_State *L, int arg, - size_t *l); -LUALIB_API const char *(luaL_optlstring) (lua_State *L, int arg, - const char *def, size_t *l); -LUALIB_API lua_Number (luaL_checknumber) (lua_State *L, int arg); -LUALIB_API lua_Number (luaL_optnumber) (lua_State *L, int arg, lua_Number def); - -LUALIB_API lua_Integer (luaL_checkinteger) (lua_State *L, int arg); -LUALIB_API lua_Integer (luaL_optinteger) (lua_State *L, int arg, - lua_Integer def); - -LUALIB_API void (luaL_checkstack) (lua_State *L, int sz, const char *msg); -LUALIB_API void (luaL_checktype) (lua_State *L, int arg, int t); -LUALIB_API void (luaL_checkany) (lua_State *L, int arg); - -LUALIB_API int (luaL_newmetatable) (lua_State *L, const char *tname); -LUALIB_API void (luaL_setmetatable) (lua_State *L, const char *tname); -LUALIB_API void *(luaL_testudata) (lua_State *L, int ud, const char *tname); -LUALIB_API void *(luaL_checkudata) (lua_State *L, int ud, const char *tname); - -LUALIB_API void (luaL_where) (lua_State *L, int lvl); -LUALIB_API int (luaL_error) (lua_State *L, const char *fmt, ...); - -LUALIB_API int (luaL_checkoption) (lua_State *L, int arg, const char *def, - const char *const lst[]); - -LUALIB_API int (luaL_fileresult) (lua_State *L, int stat, const char *fname); -LUALIB_API int (luaL_execresult) (lua_State *L, int stat); - -/* pre-defined references */ -#define LUA_NOREF (-2) -#define LUA_REFNIL (-1) - -LUALIB_API int (luaL_ref) (lua_State *L, int t); -LUALIB_API void (luaL_unref) (lua_State *L, int t, int ref); - -LUALIB_API int (luaL_loadfilex) (lua_State *L, const char *filename, - const char *mode); - -#define luaL_loadfile(L,f) luaL_loadfilex(L,f,NULL) - -LUALIB_API int (luaL_loadbufferx) (lua_State *L, const char *buff, size_t sz, - const char *name, const char *mode); -LUALIB_API int (luaL_loadstring) (lua_State *L, const char *s); - -LUALIB_API lua_State *(luaL_newstate) (void); - -LUALIB_API lua_Integer (luaL_len) (lua_State *L, int idx); - -LUALIB_API const char *(luaL_gsub) (lua_State *L, const char *s, const char *p, - const char *r); - -LUALIB_API void (luaL_setfuncs) (lua_State *L, const luaL_Reg *l, int nup); - -LUALIB_API int (luaL_getsubtable) (lua_State *L, int idx, const char *fname); - -LUALIB_API void (luaL_traceback) (lua_State *L, lua_State *L1, - const char *msg, int level); - -LUALIB_API void (luaL_requiref) (lua_State *L, const char *modname, - lua_CFunction openf, int glb); - -/* -** =============================================================== -** some useful macros -** =============================================================== -*/ - - -#define luaL_newlibtable(L,l) \ - lua_createtable(L, 0, sizeof(l)/sizeof((l)[0]) - 1) - -#define luaL_newlib(L,l) \ - (luaL_checkversion(L), luaL_newlibtable(L,l), luaL_setfuncs(L,l,0)) - -#define luaL_argcheck(L, cond,arg,extramsg) \ - ((void)((cond) || luaL_argerror(L, (arg), (extramsg)))) -#define luaL_checkstring(L,n) (luaL_checklstring(L, (n), NULL)) -#define luaL_optstring(L,n,d) (luaL_optlstring(L, (n), (d), NULL)) - -#define luaL_typename(L,i) lua_typename(L, lua_type(L,(i))) - -#define luaL_dofile(L, fn) \ - (luaL_loadfile(L, fn) || lua_pcall(L, 0, LUA_MULTRET, 0)) - -#define luaL_dostring(L, s) \ - (luaL_loadstring(L, s) || lua_pcall(L, 0, LUA_MULTRET, 0)) - -#define luaL_getmetatable(L,n) (lua_getfield(L, LUA_REGISTRYINDEX, (n))) - -#define luaL_opt(L,f,n,d) (lua_isnoneornil(L,(n)) ? (d) : f(L,(n))) - -#define luaL_loadbuffer(L,s,sz,n) luaL_loadbufferx(L,s,sz,n,NULL) - - -/* -** {====================================================== -** Generic Buffer manipulation -** ======================================================= -*/ - -typedef struct luaL_Buffer { - char *b; /* buffer address */ - size_t size; /* buffer size */ - size_t n; /* number of characters in buffer */ - lua_State *L; - char initb[LUAL_BUFFERSIZE]; /* initial buffer */ -} luaL_Buffer; - - -#define luaL_addchar(B,c) \ - ((void)((B)->n < (B)->size || luaL_prepbuffsize((B), 1)), \ - ((B)->b[(B)->n++] = (c))) - -#define luaL_addsize(B,s) ((B)->n += (s)) - -LUALIB_API void (luaL_buffinit) (lua_State *L, luaL_Buffer *B); -LUALIB_API char *(luaL_prepbuffsize) (luaL_Buffer *B, size_t sz); -LUALIB_API void (luaL_addlstring) (luaL_Buffer *B, const char *s, size_t l); -LUALIB_API void (luaL_addstring) (luaL_Buffer *B, const char *s); -LUALIB_API void (luaL_addvalue) (luaL_Buffer *B); -LUALIB_API void (luaL_pushresult) (luaL_Buffer *B); -LUALIB_API void (luaL_pushresultsize) (luaL_Buffer *B, size_t sz); -LUALIB_API char *(luaL_buffinitsize) (lua_State *L, luaL_Buffer *B, size_t sz); - -#define luaL_prepbuffer(B) luaL_prepbuffsize(B, LUAL_BUFFERSIZE) - -/* }====================================================== */ - - - -/* -** {====================================================== -** File handles for IO library -** ======================================================= -*/ - -/* -** A file handle is a userdata with metatable 'LUA_FILEHANDLE' and -** initial structure 'luaL_Stream' (it may contain other fields -** after that initial structure). -*/ - -#define LUA_FILEHANDLE "FILE*" - - -typedef struct luaL_Stream { - FILE *f; /* stream (NULL for incompletely created streams) */ - lua_CFunction closef; /* to close stream (NULL for closed streams) */ -} luaL_Stream; - -/* }====================================================== */ - - - -/* compatibility with old module system */ -#if defined(LUA_COMPAT_MODULE) - -LUALIB_API void (luaL_pushmodule) (lua_State *L, const char *modname, - int sizehint); -LUALIB_API void (luaL_openlib) (lua_State *L, const char *libname, - const luaL_Reg *l, int nup); - -#define luaL_register(L,n,l) (luaL_openlib(L,(n),(l),0)) - -#endif - - -/* -** {================================================================== -** "Abstraction Layer" for basic report of messages and errors -** =================================================================== -*/ - -/* print a string */ -#if !defined(lua_writestring) -#define lua_writestring(s,l) fwrite((s), sizeof(char), (l), stdout) -#endif - -/* print a newline and flush the output */ -#if !defined(lua_writeline) -#define lua_writeline() (lua_writestring("\n", 1), fflush(stdout)) -#endif - -/* print an error message */ -#if !defined(lua_writestringerror) -#define lua_writestringerror(s,p) \ - (fprintf(stderr, (s), (p)), fflush(stderr)) -#endif - -/* }================================================================== */ - - -/* -** {============================================================ -** Compatibility with deprecated conversions -** ============================================================= -*/ -#if defined(LUA_COMPAT_APIINTCASTS) - -#define luaL_checkunsigned(L,a) ((lua_Unsigned)luaL_checkinteger(L,a)) -#define luaL_optunsigned(L,a,d) \ - ((lua_Unsigned)luaL_optinteger(L,a,(lua_Integer)(d))) - -#define luaL_checkint(L,n) ((int)luaL_checkinteger(L, (n))) -#define luaL_optint(L,n,d) ((int)luaL_optinteger(L, (n), (d))) - -#define luaL_checklong(L,n) ((long)luaL_checkinteger(L, (n))) -#define luaL_optlong(L,n,d) ((long)luaL_optinteger(L, (n), (d))) - -#endif -/* }============================================================ */ - - - -#endif - - diff --git a/thirdparty/include/Lua/lua.h b/thirdparty/include/Lua/lua.h deleted file mode 100644 index 6bb2042ac..000000000 --- a/thirdparty/include/Lua/lua.h +++ /dev/null @@ -1,485 +0,0 @@ -/* -** $Id: lua.h,v 1.325 2014/12/26 17:24:27 roberto Exp $ -** Lua - A Scripting Language -** Lua.org, PUC-Rio, Brazil (http://www.lua.org) -** See Copyright Notice at the end of this file -*/ - - -#ifndef lua_h -#define lua_h - -#include -#include - - -#include - - -#define LUA_VERSION_MAJOR "5" -#define LUA_VERSION_MINOR "3" -#define LUA_VERSION_NUM 503 -#define LUA_VERSION_RELEASE "0" - -#define LUA_VERSION "Lua " LUA_VERSION_MAJOR "." LUA_VERSION_MINOR -#define LUA_RELEASE LUA_VERSION "." LUA_VERSION_RELEASE -#define LUA_COPYRIGHT LUA_RELEASE " Copyright (C) 1994-2015 Lua.org, PUC-Rio" -#define LUA_AUTHORS "R. Ierusalimschy, L. H. de Figueiredo, W. Celes" - - -/* mark for precompiled code ('Lua') */ -#define LUA_SIGNATURE "\x1bLua" - -/* option for multiple returns in 'lua_pcall' and 'lua_call' */ -#define LUA_MULTRET (-1) - - -/* -** pseudo-indices -*/ -#define LUA_REGISTRYINDEX LUAI_FIRSTPSEUDOIDX -#define lua_upvalueindex(i) (LUA_REGISTRYINDEX - (i)) - - -/* thread status */ -#define LUA_OK 0 -#define LUA_YIELD 1 -#define LUA_ERRRUN 2 -#define LUA_ERRSYNTAX 3 -#define LUA_ERRMEM 4 -#define LUA_ERRGCMM 5 -#define LUA_ERRERR 6 - - -typedef struct lua_State lua_State; - - -/* -** basic types -*/ -#define LUA_TNONE (-1) - -#define LUA_TNIL 0 -#define LUA_TBOOLEAN 1 -#define LUA_TLIGHTUSERDATA 2 -#define LUA_TNUMBER 3 -#define LUA_TSTRING 4 -#define LUA_TTABLE 5 -#define LUA_TFUNCTION 6 -#define LUA_TUSERDATA 7 -#define LUA_TTHREAD 8 - -#define LUA_NUMTAGS 9 - - - -/* minimum Lua stack available to a C function */ -#define LUA_MINSTACK 20 - - -/* predefined values in the registry */ -#define LUA_RIDX_MAINTHREAD 1 -#define LUA_RIDX_GLOBALS 2 -#define LUA_RIDX_LAST LUA_RIDX_GLOBALS - - -/* type of numbers in Lua */ -typedef LUA_NUMBER lua_Number; - - -/* type for integer functions */ -typedef LUA_INTEGER lua_Integer; - -/* unsigned integer type */ -typedef LUA_UNSIGNED lua_Unsigned; - -/* type for continuation-function contexts */ -typedef LUA_KCONTEXT lua_KContext; - - -/* -** Type for C functions registered with Lua -*/ -typedef int (*lua_CFunction) (lua_State *L); - -/* -** Type for continuation functions -*/ -typedef int (*lua_KFunction) (lua_State *L, int status, lua_KContext ctx); - - -/* -** Type for functions that read/write blocks when loading/dumping Lua chunks -*/ -typedef const char * (*lua_Reader) (lua_State *L, void *ud, size_t *sz); - -typedef int (*lua_Writer) (lua_State *L, const void *p, size_t sz, void *ud); - - -/* -** Type for memory-allocation functions -*/ -typedef void * (*lua_Alloc) (void *ud, void *ptr, size_t osize, size_t nsize); - - - -/* -** generic extra include file -*/ -#if defined(LUA_USER_H) -#include LUA_USER_H -#endif - - -/* -** RCS ident string -*/ -extern const char lua_ident[]; - - -/* -** state manipulation -*/ -LUA_API lua_State *(lua_newstate) (lua_Alloc f, void *ud); -LUA_API void (lua_close) (lua_State *L); -LUA_API lua_State *(lua_newthread) (lua_State *L); - -LUA_API lua_CFunction (lua_atpanic) (lua_State *L, lua_CFunction panicf); - - -LUA_API const lua_Number *(lua_version) (lua_State *L); - - -/* -** basic stack manipulation -*/ -LUA_API int (lua_absindex) (lua_State *L, int idx); -LUA_API int (lua_gettop) (lua_State *L); -LUA_API void (lua_settop) (lua_State *L, int idx); -LUA_API void (lua_pushvalue) (lua_State *L, int idx); -LUA_API void (lua_rotate) (lua_State *L, int idx, int n); -LUA_API void (lua_copy) (lua_State *L, int fromidx, int toidx); -LUA_API int (lua_checkstack) (lua_State *L, int n); - -LUA_API void (lua_xmove) (lua_State *from, lua_State *to, int n); - - -/* -** access functions (stack -> C) -*/ - -LUA_API int (lua_isnumber) (lua_State *L, int idx); -LUA_API int (lua_isstring) (lua_State *L, int idx); -LUA_API int (lua_iscfunction) (lua_State *L, int idx); -LUA_API int (lua_isinteger) (lua_State *L, int idx); -LUA_API int (lua_isuserdata) (lua_State *L, int idx); -LUA_API int (lua_type) (lua_State *L, int idx); -LUA_API const char *(lua_typename) (lua_State *L, int tp); - -LUA_API lua_Number (lua_tonumberx) (lua_State *L, int idx, int *isnum); -LUA_API lua_Integer (lua_tointegerx) (lua_State *L, int idx, int *isnum); -LUA_API int (lua_toboolean) (lua_State *L, int idx); -LUA_API const char *(lua_tolstring) (lua_State *L, int idx, size_t *len); -LUA_API size_t (lua_rawlen) (lua_State *L, int idx); -LUA_API lua_CFunction (lua_tocfunction) (lua_State *L, int idx); -LUA_API void *(lua_touserdata) (lua_State *L, int idx); -LUA_API lua_State *(lua_tothread) (lua_State *L, int idx); -LUA_API const void *(lua_topointer) (lua_State *L, int idx); - - -/* -** Comparison and arithmetic functions -*/ - -#define LUA_OPADD 0 /* ORDER TM, ORDER OP */ -#define LUA_OPSUB 1 -#define LUA_OPMUL 2 -#define LUA_OPMOD 3 -#define LUA_OPPOW 4 -#define LUA_OPDIV 5 -#define LUA_OPIDIV 6 -#define LUA_OPBAND 7 -#define LUA_OPBOR 8 -#define LUA_OPBXOR 9 -#define LUA_OPSHL 10 -#define LUA_OPSHR 11 -#define LUA_OPUNM 12 -#define LUA_OPBNOT 13 - -LUA_API void (lua_arith) (lua_State *L, int op); - -#define LUA_OPEQ 0 -#define LUA_OPLT 1 -#define LUA_OPLE 2 - -LUA_API int (lua_rawequal) (lua_State *L, int idx1, int idx2); -LUA_API int (lua_compare) (lua_State *L, int idx1, int idx2, int op); - - -/* -** push functions (C -> stack) -*/ -LUA_API void (lua_pushnil) (lua_State *L); -LUA_API void (lua_pushnumber) (lua_State *L, lua_Number n); -LUA_API void (lua_pushinteger) (lua_State *L, lua_Integer n); -LUA_API const char *(lua_pushlstring) (lua_State *L, const char *s, size_t len); -LUA_API const char *(lua_pushstring) (lua_State *L, const char *s); -LUA_API const char *(lua_pushvfstring) (lua_State *L, const char *fmt, - va_list argp); -LUA_API const char *(lua_pushfstring) (lua_State *L, const char *fmt, ...); -LUA_API void (lua_pushcclosure) (lua_State *L, lua_CFunction fn, int n); -LUA_API void (lua_pushboolean) (lua_State *L, int b); -LUA_API void (lua_pushlightuserdata) (lua_State *L, void *p); -LUA_API int (lua_pushthread) (lua_State *L); - - -/* -** get functions (Lua -> stack) -*/ -LUA_API int (lua_getglobal) (lua_State *L, const char *name); -LUA_API int (lua_gettable) (lua_State *L, int idx); -LUA_API int (lua_getfield) (lua_State *L, int idx, const char *k); -LUA_API int (lua_geti) (lua_State *L, int idx, lua_Integer n); -LUA_API int (lua_rawget) (lua_State *L, int idx); -LUA_API int (lua_rawgeti) (lua_State *L, int idx, lua_Integer n); -LUA_API int (lua_rawgetp) (lua_State *L, int idx, const void *p); - -LUA_API void (lua_createtable) (lua_State *L, int narr, int nrec); -LUA_API void *(lua_newuserdata) (lua_State *L, size_t sz); -LUA_API int (lua_getmetatable) (lua_State *L, int objindex); -LUA_API int (lua_getuservalue) (lua_State *L, int idx); - - -/* -** set functions (stack -> Lua) -*/ -LUA_API void (lua_setglobal) (lua_State *L, const char *name); -LUA_API void (lua_settable) (lua_State *L, int idx); -LUA_API void (lua_setfield) (lua_State *L, int idx, const char *k); -LUA_API void (lua_seti) (lua_State *L, int idx, lua_Integer n); -LUA_API void (lua_rawset) (lua_State *L, int idx); -LUA_API void (lua_rawseti) (lua_State *L, int idx, lua_Integer n); -LUA_API void (lua_rawsetp) (lua_State *L, int idx, const void *p); -LUA_API int (lua_setmetatable) (lua_State *L, int objindex); -LUA_API void (lua_setuservalue) (lua_State *L, int idx); - - -/* -** 'load' and 'call' functions (load and run Lua code) -*/ -LUA_API void (lua_callk) (lua_State *L, int nargs, int nresults, - lua_KContext ctx, lua_KFunction k); -#define lua_call(L,n,r) lua_callk(L, (n), (r), 0, NULL) - -LUA_API int (lua_pcallk) (lua_State *L, int nargs, int nresults, int errfunc, - lua_KContext ctx, lua_KFunction k); -#define lua_pcall(L,n,r,f) lua_pcallk(L, (n), (r), (f), 0, NULL) - -LUA_API int (lua_load) (lua_State *L, lua_Reader reader, void *dt, - const char *chunkname, const char *mode); - -LUA_API int (lua_dump) (lua_State *L, lua_Writer writer, void *data, int strip); - - -/* -** coroutine functions -*/ -LUA_API int (lua_yieldk) (lua_State *L, int nresults, lua_KContext ctx, - lua_KFunction k); -LUA_API int (lua_resume) (lua_State *L, lua_State *from, int narg); -LUA_API int (lua_status) (lua_State *L); -LUA_API int (lua_isyieldable) (lua_State *L); - -#define lua_yield(L,n) lua_yieldk(L, (n), 0, NULL) - - -/* -** garbage-collection function and options -*/ - -#define LUA_GCSTOP 0 -#define LUA_GCRESTART 1 -#define LUA_GCCOLLECT 2 -#define LUA_GCCOUNT 3 -#define LUA_GCCOUNTB 4 -#define LUA_GCSTEP 5 -#define LUA_GCSETPAUSE 6 -#define LUA_GCSETSTEPMUL 7 -#define LUA_GCISRUNNING 9 - -LUA_API int (lua_gc) (lua_State *L, int what, int data); - - -/* -** miscellaneous functions -*/ - -LUA_API int (lua_error) (lua_State *L); - -LUA_API int (lua_next) (lua_State *L, int idx); - -LUA_API void (lua_concat) (lua_State *L, int n); -LUA_API void (lua_len) (lua_State *L, int idx); - -LUA_API size_t (lua_stringtonumber) (lua_State *L, const char *s); - -LUA_API lua_Alloc (lua_getallocf) (lua_State *L, void **ud); -LUA_API void (lua_setallocf) (lua_State *L, lua_Alloc f, void *ud); - - - -/* -** {============================================================== -** some useful macros -** =============================================================== -*/ - -#define lua_getextraspace(L) ((void *)((char *)(L) - LUA_EXTRASPACE)) - -#define lua_tonumber(L,i) lua_tonumberx(L,(i),NULL) -#define lua_tointeger(L,i) lua_tointegerx(L,(i),NULL) - -#define lua_pop(L,n) lua_settop(L, -(n)-1) - -#define lua_newtable(L) lua_createtable(L, 0, 0) - -#define lua_register(L,n,f) (lua_pushcfunction(L, (f)), lua_setglobal(L, (n))) - -#define lua_pushcfunction(L,f) lua_pushcclosure(L, (f), 0) - -#define lua_isfunction(L,n) (lua_type(L, (n)) == LUA_TFUNCTION) -#define lua_istable(L,n) (lua_type(L, (n)) == LUA_TTABLE) -#define lua_islightuserdata(L,n) (lua_type(L, (n)) == LUA_TLIGHTUSERDATA) -#define lua_isnil(L,n) (lua_type(L, (n)) == LUA_TNIL) -#define lua_isboolean(L,n) (lua_type(L, (n)) == LUA_TBOOLEAN) -#define lua_isthread(L,n) (lua_type(L, (n)) == LUA_TTHREAD) -#define lua_isnone(L,n) (lua_type(L, (n)) == LUA_TNONE) -#define lua_isnoneornil(L, n) (lua_type(L, (n)) <= 0) - -#define lua_pushliteral(L, s) \ - lua_pushlstring(L, "" s, (sizeof(s)/sizeof(char))-1) - -#define lua_pushglobaltable(L) \ - lua_rawgeti(L, LUA_REGISTRYINDEX, LUA_RIDX_GLOBALS) - -#define lua_tostring(L,i) lua_tolstring(L, (i), NULL) - - -#define lua_insert(L,idx) lua_rotate(L, (idx), 1) - -#define lua_remove(L,idx) (lua_rotate(L, (idx), -1), lua_pop(L, 1)) - -#define lua_replace(L,idx) (lua_copy(L, -1, (idx)), lua_pop(L, 1)) - -/* }============================================================== */ - - -/* -** {============================================================== -** compatibility macros for unsigned conversions -** =============================================================== -*/ -#if defined(LUA_COMPAT_APIINTCASTS) - -#define lua_pushunsigned(L,n) lua_pushinteger(L, (lua_Integer)(n)) -#define lua_tounsignedx(L,i,is) ((lua_Unsigned)lua_tointegerx(L,i,is)) -#define lua_tounsigned(L,i) lua_tounsignedx(L,(i),NULL) - -#endif -/* }============================================================== */ - -/* -** {====================================================================== -** Debug API -** ======================================================================= -*/ - - -/* -** Event codes -*/ -#define LUA_HOOKCALL 0 -#define LUA_HOOKRET 1 -#define LUA_HOOKLINE 2 -#define LUA_HOOKCOUNT 3 -#define LUA_HOOKTAILCALL 4 - - -/* -** Event masks -*/ -#define LUA_MASKCALL (1 << LUA_HOOKCALL) -#define LUA_MASKRET (1 << LUA_HOOKRET) -#define LUA_MASKLINE (1 << LUA_HOOKLINE) -#define LUA_MASKCOUNT (1 << LUA_HOOKCOUNT) - -typedef struct lua_Debug lua_Debug; /* activation record */ - - -/* Functions to be called by the debugger in specific events */ -typedef void (*lua_Hook) (lua_State *L, lua_Debug *ar); - - -LUA_API int (lua_getstack) (lua_State *L, int level, lua_Debug *ar); -LUA_API int (lua_getinfo) (lua_State *L, const char *what, lua_Debug *ar); -LUA_API const char *(lua_getlocal) (lua_State *L, const lua_Debug *ar, int n); -LUA_API const char *(lua_setlocal) (lua_State *L, const lua_Debug *ar, int n); -LUA_API const char *(lua_getupvalue) (lua_State *L, int funcindex, int n); -LUA_API const char *(lua_setupvalue) (lua_State *L, int funcindex, int n); - -LUA_API void *(lua_upvalueid) (lua_State *L, int fidx, int n); -LUA_API void (lua_upvaluejoin) (lua_State *L, int fidx1, int n1, - int fidx2, int n2); - -LUA_API void (lua_sethook) (lua_State *L, lua_Hook func, int mask, int count); -LUA_API lua_Hook (lua_gethook) (lua_State *L); -LUA_API int (lua_gethookmask) (lua_State *L); -LUA_API int (lua_gethookcount) (lua_State *L); - - -struct lua_Debug { - int event; - const char *name; /* (n) */ - const char *namewhat; /* (n) 'global', 'local', 'field', 'method' */ - const char *what; /* (S) 'Lua', 'C', 'main', 'tail' */ - const char *source; /* (S) */ - int currentline; /* (l) */ - int linedefined; /* (S) */ - int lastlinedefined; /* (S) */ - unsigned char nups; /* (u) number of upvalues */ - unsigned char nparams;/* (u) number of parameters */ - char isvararg; /* (u) */ - char istailcall; /* (t) */ - char short_src[LUA_IDSIZE]; /* (S) */ - /* private part */ - struct CallInfo *i_ci; /* active function */ -}; - -/* }====================================================================== */ - - -/****************************************************************************** -* Copyright (C) 1994-2015 Lua.org, PUC-Rio. -* -* Permission is hereby granted, free of charge, to any person obtaining -* a copy of this software and associated documentation files (the -* "Software"), to deal in the Software without restriction, including -* without limitation the rights to use, copy, modify, merge, publish, -* distribute, sublicense, and/or sell copies of the Software, and to -* permit persons to whom the Software is furnished to do so, subject to -* the following conditions: -* -* The above copyright notice and this permission notice shall be -* included in all copies or substantial portions of the Software. -* -* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, -* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF -* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. -* IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY -* CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, -* TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE -* SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. -******************************************************************************/ - - -#endif diff --git a/thirdparty/include/Lua/luaconf.h b/thirdparty/include/Lua/luaconf.h deleted file mode 100644 index fd28d21ae..000000000 --- a/thirdparty/include/Lua/luaconf.h +++ /dev/null @@ -1,735 +0,0 @@ -/* -** $Id: luaconf.h,v 1.238 2014/12/29 13:27:55 roberto Exp $ -** Configuration file for Lua -** See Copyright Notice in lua.h -*/ - - -#ifndef luaconf_h -#define luaconf_h - -#include -#include - - -/* -** =================================================================== -** Search for "@@" to find all configurable definitions. -** =================================================================== -*/ - - -/* -** {==================================================================== -** System Configuration: macros to adapt (if needed) Lua to some -** particular platform, for instance compiling it with 32-bit numbers or -** restricting it to C89. -** ===================================================================== -*/ - -/* -@@ LUA_32BITS enables Lua with 32-bit integers and 32-bit floats. You -** can also define LUA_32BITS in the make file, but changing here you -** ensure that all software connected to Lua will be compiled with the -** same configuration. -*/ -/* #define LUA_32BITS */ - - -/* -@@ LUA_USE_C89 controls the use of non-ISO-C89 features. -** Define it if you want Lua to avoid the use of a few C99 features -** or Windows-specific features on Windows. -*/ -/* #define LUA_USE_C89 */ - - -/* -** By default, Lua on Windows use (some) specific Windows features -*/ -#if !defined(LUA_USE_C89) && defined(_WIN32) && !defined(_WIN32_WCE) -#define LUA_USE_WINDOWS /* enable goodies for regular Windows */ -#endif - - -#if defined(LUA_USE_WINDOWS) -#define LUA_DL_DLL /* enable support for DLL */ -#define LUA_USE_C89 /* broadly, Windows is C89 */ -#endif - - -#if defined(LUA_USE_LINUX) -#define LUA_USE_POSIX -#define LUA_USE_DLOPEN /* needs an extra library: -ldl */ -#define LUA_USE_READLINE /* needs some extra libraries */ -#endif - - -#if defined(LUA_USE_MACOSX) -#define LUA_USE_POSIX -#define LUA_USE_DLOPEN /* MacOS does not need -ldl */ -#define LUA_USE_READLINE /* needs an extra library: -lreadline */ -#endif - - -/* -@@ LUA_C89_NUMBERS ensures that Lua uses the largest types available for -** C89 ('long' and 'double'); Windows always has '__int64', so it does -** not need to use this case. -*/ -#if defined(LUA_USE_C89) && !defined(LUA_USE_WINDOWS) -#define LUA_C89_NUMBERS -#endif - - - -/* -@@ LUAI_BITSINT defines the (minimum) number of bits in an 'int'. -*/ -/* avoid undefined shifts */ -#if ((INT_MAX >> 15) >> 15) >= 1 -#define LUAI_BITSINT 32 -#else -/* 'int' always must have at least 16 bits */ -#define LUAI_BITSINT 16 -#endif - - -/* -@@ LUA_INT_INT / LUA_INT_LONG / LUA_INT_LONGLONG defines the type for -** Lua integers. -@@ LUA_REAL_FLOAT / LUA_REAL_DOUBLE / LUA_REAL_LONGDOUBLE defines -** the type for Lua floats. -** Lua should work fine with any mix of these options (if supported -** by your C compiler). The usual configurations are 64-bit integers -** and 'double' (the default), 32-bit integers and 'float' (for -** restricted platforms), and 'long'/'double' (for C compilers not -** compliant with C99, which may not have support for 'long long'). -*/ - -#if defined(LUA_32BITS) /* { */ -/* -** 32-bit integers and 'float' -*/ -#if LUAI_BITSINT >= 32 /* use 'int' if big enough */ -#define LUA_INT_INT -#else /* otherwise use 'long' */ -#define LUA_INT_LONG -#endif -#define LUA_REAL_FLOAT - -#elif defined(LUA_C89_NUMBERS) /* }{ */ -/* -** largest types available for C89 ('long' and 'double') -*/ -#define LUA_INT_LONG -#define LUA_REAL_DOUBLE - -#else /* }{ */ -/* -** default configuration for 64-bit Lua ('long long' and 'double') -*/ -#define LUA_INT_LONGLONG -#define LUA_REAL_DOUBLE - -#endif /* } */ - -/* }================================================================== */ - - - - -/* -** {================================================================== -** Configuration for Paths. -** =================================================================== -*/ - -/* -@@ LUA_PATH_DEFAULT is the default path that Lua uses to look for -** Lua libraries. -@@ LUA_CPATH_DEFAULT is the default path that Lua uses to look for -** C libraries. -** CHANGE them if your machine has a non-conventional directory -** hierarchy or if you want to install your libraries in -** non-conventional directories. -*/ -#define LUA_VDIR LUA_VERSION_MAJOR "." LUA_VERSION_MINOR -#if defined(_WIN32) /* { */ -/* -** In Windows, any exclamation mark ('!') in the path is replaced by the -** path of the directory of the executable file of the current process. -*/ -#define LUA_LDIR "!\\lua\\" -#define LUA_CDIR "!\\" -#define LUA_SHRDIR "!\\..\\share\\lua\\" LUA_VDIR "\\" -#define LUA_PATH_DEFAULT \ - LUA_LDIR"?.lua;" LUA_LDIR"?\\init.lua;" \ - LUA_CDIR"?.lua;" LUA_CDIR"?\\init.lua;" \ - LUA_SHRDIR"?.lua;" LUA_SHRDIR"?\\init.lua;" \ - ".\\?.lua;" ".\\?\\init.lua" -#define LUA_CPATH_DEFAULT \ - LUA_CDIR"?.dll;" \ - LUA_CDIR"..\\lib\\lua\\" LUA_VDIR "\\?.dll;" \ - LUA_CDIR"loadall.dll;" ".\\?.dll" - -#else /* }{ */ - -#define LUA_ROOT "/usr/local/" -#define LUA_LDIR LUA_ROOT "share/lua/" LUA_VDIR "/" -#define LUA_CDIR LUA_ROOT "lib/lua/" LUA_VDIR "/" -#define LUA_PATH_DEFAULT \ - LUA_LDIR"?.lua;" LUA_LDIR"?/init.lua;" \ - LUA_CDIR"?.lua;" LUA_CDIR"?/init.lua;" \ - "./?.lua;" "./?/init.lua" -#define LUA_CPATH_DEFAULT \ - LUA_CDIR"?.so;" LUA_CDIR"loadall.so;" "./?.so" -#endif /* } */ - - -/* -@@ LUA_DIRSEP is the directory separator (for submodules). -** CHANGE it if your machine does not use "/" as the directory separator -** and is not Windows. (On Windows Lua automatically uses "\".) -*/ -#if defined(_WIN32) -#define LUA_DIRSEP "\\" -#else -#define LUA_DIRSEP "/" -#endif - -/* }================================================================== */ - - -/* -** {================================================================== -** Marks for exported symbols in the C code -** =================================================================== -*/ - -/* -@@ LUA_API is a mark for all core API functions. -@@ LUALIB_API is a mark for all auxiliary library functions. -@@ LUAMOD_API is a mark for all standard library opening functions. -** CHANGE them if you need to define those functions in some special way. -** For instance, if you want to create one Windows DLL with the core and -** the libraries, you may want to use the following definition (define -** LUA_BUILD_AS_DLL to get it). -*/ -#if defined(LUA_BUILD_AS_DLL) /* { */ - -#if defined(LUA_CORE) || defined(LUA_LIB) /* { */ -#define LUA_API __declspec(dllexport) -#else /* }{ */ -#define LUA_API __declspec(dllimport) -#endif /* } */ - -#else /* }{ */ - -#define LUA_API extern - -#endif /* } */ - - -/* more often than not the libs go together with the core */ -#define LUALIB_API LUA_API -#define LUAMOD_API LUALIB_API - - -/* -@@ LUAI_FUNC is a mark for all extern functions that are not to be -** exported to outside modules. -@@ LUAI_DDEF and LUAI_DDEC are marks for all extern (const) variables -** that are not to be exported to outside modules (LUAI_DDEF for -** definitions and LUAI_DDEC for declarations). -** CHANGE them if you need to mark them in some special way. Elf/gcc -** (versions 3.2 and later) mark them as "hidden" to optimize access -** when Lua is compiled as a shared library. Not all elf targets support -** this attribute. Unfortunately, gcc does not offer a way to check -** whether the target offers that support, and those without support -** give a warning about it. To avoid these warnings, change to the -** default definition. -*/ -#if defined(__GNUC__) && ((__GNUC__*100 + __GNUC_MINOR__) >= 302) && \ - defined(__ELF__) /* { */ -#define LUAI_FUNC __attribute__((visibility("hidden"))) extern -#else /* }{ */ -#define LUAI_FUNC extern -#endif /* } */ - -#define LUAI_DDEC LUAI_FUNC -#define LUAI_DDEF /* empty */ - -/* }================================================================== */ - - -/* -** {================================================================== -** Compatibility with previous versions -** =================================================================== -*/ - -/* -@@ LUA_COMPAT_5_2 controls other macros for compatibility with Lua 5.2. -@@ LUA_COMPAT_5_1 controls other macros for compatibility with Lua 5.1. -** You can define it to get all options, or change specific options -** to fit your specific needs. -*/ -#if defined(LUA_COMPAT_5_2) /* { */ - -/* -@@ LUA_COMPAT_MATHLIB controls the presence of several deprecated -** functions in the mathematical library. -*/ -#define LUA_COMPAT_MATHLIB - -/* -@@ LUA_COMPAT_BITLIB controls the presence of library 'bit32'. -*/ -#define LUA_COMPAT_BITLIB - -/* -@@ LUA_COMPAT_IPAIRS controls the effectiveness of the __ipairs metamethod. -*/ -#define LUA_COMPAT_IPAIRS - -/* -@@ LUA_COMPAT_APIINTCASTS controls the presence of macros for -** manipulating other integer types (lua_pushunsigned, lua_tounsigned, -** luaL_checkint, luaL_checklong, etc.) -*/ -#define LUA_COMPAT_APIINTCASTS - - -/* -@@ LUA_COMPAT_FLOATSTRING makes Lua format integral floats without a -@@ a float mark ('.0'). -** This macro is not on by default even in compatibility mode, -** because this is not really an incompatibility. -*/ -/* #define LUA_COMPAT_FLOATSTRING */ - -#endif /* } */ - - -#if defined(LUA_COMPAT_5_1) /* { */ - -/* -@@ LUA_COMPAT_UNPACK controls the presence of global 'unpack'. -** You can replace it with 'table.unpack'. -*/ -#define LUA_COMPAT_UNPACK - -/* -@@ LUA_COMPAT_LOADERS controls the presence of table 'package.loaders'. -** You can replace it with 'package.searchers'. -*/ -#define LUA_COMPAT_LOADERS - -/* -@@ macro 'lua_cpcall' emulates deprecated function lua_cpcall. -** You can call your C function directly (with light C functions). -*/ -#define lua_cpcall(L,f,u) \ - (lua_pushcfunction(L, (f)), \ - lua_pushlightuserdata(L,(u)), \ - lua_pcall(L,1,0,0)) - - -/* -@@ LUA_COMPAT_LOG10 defines the function 'log10' in the math library. -** You can rewrite 'log10(x)' as 'log(x, 10)'. -*/ -#define LUA_COMPAT_LOG10 - -/* -@@ LUA_COMPAT_LOADSTRING defines the function 'loadstring' in the base -** library. You can rewrite 'loadstring(s)' as 'load(s)'. -*/ -#define LUA_COMPAT_LOADSTRING - -/* -@@ LUA_COMPAT_MAXN defines the function 'maxn' in the table library. -*/ -#define LUA_COMPAT_MAXN - -/* -@@ The following macros supply trivial compatibility for some -** changes in the API. The macros themselves document how to -** change your code to avoid using them. -*/ -#define lua_strlen(L,i) lua_rawlen(L, (i)) - -#define lua_objlen(L,i) lua_rawlen(L, (i)) - -#define lua_equal(L,idx1,idx2) lua_compare(L,(idx1),(idx2),LUA_OPEQ) -#define lua_lessthan(L,idx1,idx2) lua_compare(L,(idx1),(idx2),LUA_OPLT) - -/* -@@ LUA_COMPAT_MODULE controls compatibility with previous -** module functions 'module' (Lua) and 'luaL_register' (C). -*/ -#define LUA_COMPAT_MODULE - -#endif /* } */ - -/* }================================================================== */ - - - -/* -** {================================================================== -** Configuration for Numbers. -** Change these definitions if no predefined LUA_REAL_* / LUA_INT_* -** satisfy your needs. -** =================================================================== -*/ - -/* -@@ LUA_NUMBER is the floating-point type used by Lua. -** -@@ LUAI_UACNUMBER is the result of an 'usual argument conversion' -@@ over a floating number. -** -@@ LUA_NUMBER_FRMLEN is the length modifier for writing floats. -@@ LUA_NUMBER_FMT is the format for writing floats. -@@ lua_number2str converts a float to a string. -** -@@ l_mathop allows the addition of an 'l' or 'f' to all math operations. -** -@@ lua_str2number converts a decimal numeric string to a number. -*/ - -#if defined(LUA_REAL_FLOAT) /* { single float */ - -#define LUA_NUMBER float - -#define LUAI_UACNUMBER double - -#define LUA_NUMBER_FRMLEN "" -#define LUA_NUMBER_FMT "%.7g" - -#define l_mathop(op) op##f - -#define lua_str2number(s,p) strtof((s), (p)) - - -#elif defined(LUA_REAL_LONGDOUBLE) /* }{ long double */ - -#define LUA_NUMBER long double - -#define LUAI_UACNUMBER long double - -#define LUA_NUMBER_FRMLEN "L" -#define LUA_NUMBER_FMT "%.19Lg" - -#define l_mathop(op) op##l - -#define lua_str2number(s,p) strtold((s), (p)) - -#elif defined(LUA_REAL_DOUBLE) /* }{ double */ - -#define LUA_NUMBER double - -#define LUAI_UACNUMBER double - -#define LUA_NUMBER_FRMLEN "" -#define LUA_NUMBER_FMT "%.14g" - -#define l_mathop(op) op - -#define lua_str2number(s,p) strtod((s), (p)) - -#else /* }{ */ - -#error "numeric real type not defined" - -#endif /* } */ - - -#define l_floor(x) (l_mathop(floor)(x)) - -#define lua_number2str(s,n) sprintf((s), LUA_NUMBER_FMT, (n)) - - -/* -@@ lua_numbertointeger converts a float number to an integer, or -** returns 0 if float is not within the range of a lua_Integer. -** (The range comparisons are tricky because of rounding. The tests -** here assume a two-complement representation, where MININTEGER always -** has an exact representation as a float; MAXINTEGER may not have one, -** and therefore its conversion to float may have an ill-defined value.) -*/ -#define lua_numbertointeger(n,p) \ - ((n) >= (LUA_NUMBER)(LUA_MININTEGER) && \ - (n) < -(LUA_NUMBER)(LUA_MININTEGER) && \ - (*(p) = (LUA_INTEGER)(n), 1)) - - -/* -@@ The luai_num* macros define the primitive operations over numbers. -** They should work for any size of floating numbers. -*/ - -/* the following operations need the math library */ -#if defined(lobject_c) || defined(lvm_c) -#include - -/* floor division (defined as 'floor(a/b)') */ -#define luai_numidiv(L,a,b) ((void)L, l_mathop(floor)(luai_numdiv(L,a,b))) - -/* -** module: defined as 'a - floor(a/b)*b'; the previous definition gives -** NaN when 'b' is huge, but the result should be 'a'. 'fmod' gives the -** result of 'a - trunc(a/b)*b', and therefore must be corrected when -** 'trunc(a/b) ~= floor(a/b)'. That happens when the division has a -** non-integer negative result, which is equivalent to the test below -*/ -#define luai_nummod(L,a,b,m) \ - { (m) = l_mathop(fmod)(a,b); if ((m)*(b) < 0) (m) += (b); } - -/* exponentiation */ -#define luai_numpow(L,a,b) ((void)L, l_mathop(pow)(a,b)) - -#endif - -/* these are quite standard operations */ -#if defined(LUA_CORE) -#define luai_numadd(L,a,b) ((a)+(b)) -#define luai_numsub(L,a,b) ((a)-(b)) -#define luai_nummul(L,a,b) ((a)*(b)) -#define luai_numdiv(L,a,b) ((a)/(b)) -#define luai_numunm(L,a) (-(a)) -#define luai_numeq(a,b) ((a)==(b)) -#define luai_numlt(a,b) ((a)<(b)) -#define luai_numle(a,b) ((a)<=(b)) -#define luai_numisnan(a) (!luai_numeq((a), (a))) -#endif - - -/* -@@ LUA_INTEGER is the integer type used by Lua. -** -@@ LUA_UNSIGNED is the unsigned version of LUA_INTEGER. -** -@@ LUAI_UACINT is the result of an 'usual argument conversion' -@@ over a lUA_INTEGER. -@@ LUA_INTEGER_FRMLEN is the length modifier for reading/writing integers. -@@ LUA_INTEGER_FMT is the format for writing integers. -@@ LUA_MAXINTEGER is the maximum value for a LUA_INTEGER. -@@ LUA_MININTEGER is the minimum value for a LUA_INTEGER. -@@ lua_integer2str converts an integer to a string. -*/ - - -/* The following definitions are good for most cases here */ - -#define LUA_INTEGER_FMT "%" LUA_INTEGER_FRMLEN "d" -#define lua_integer2str(s,n) sprintf((s), LUA_INTEGER_FMT, (n)) - -#define LUAI_UACINT LUA_INTEGER - -/* -** use LUAI_UACINT here to avoid problems with promotions (which -** can turn a comparison between unsigneds into a signed comparison) -*/ -#define LUA_UNSIGNED unsigned LUAI_UACINT - - -/* now the variable definitions */ - -#if defined(LUA_INT_INT) /* { int */ - -#define LUA_INTEGER int -#define LUA_INTEGER_FRMLEN "" - -#define LUA_MAXINTEGER INT_MAX -#define LUA_MININTEGER INT_MIN - -#elif defined(LUA_INT_LONG) /* }{ long */ - -#define LUA_INTEGER long -#define LUA_INTEGER_FRMLEN "l" - -#define LUA_MAXINTEGER LONG_MAX -#define LUA_MININTEGER LONG_MIN - -#elif defined(LUA_INT_LONGLONG) /* }{ long long */ - -#if defined(LLONG_MAX) /* { */ -/* use ISO C99 stuff */ - -#define LUA_INTEGER long long -#define LUA_INTEGER_FRMLEN "ll" - -#define LUA_MAXINTEGER LLONG_MAX -#define LUA_MININTEGER LLONG_MIN - -#elif defined(LUA_USE_WINDOWS) /* }{ */ -/* in Windows, can use specific Windows types */ - -#define LUA_INTEGER __int64 -#define LUA_INTEGER_FRMLEN "I64" - -#define LUA_MAXINTEGER _I64_MAX -#define LUA_MININTEGER _I64_MIN - -#else /* }{ */ - -#error "Compiler does not support 'long long'. Use option '-DLUA_32BITS' \ - or '-DLUA_C89_NUMBERS' (see file 'luaconf.h' for details)" - -#endif /* } */ - -#else /* }{ */ - -#error "numeric integer type not defined" - -#endif /* } */ - -/* }================================================================== */ - - -/* -** {================================================================== -** Dependencies with C99 -** =================================================================== -*/ - -/* -@@ lua_strx2number converts an hexadecimal numeric string to a number. -** In C99, 'strtod' does both conversions. Otherwise, you can -** leave 'lua_strx2number' undefined and Lua will provide its own -** implementation. -*/ -#if !defined(LUA_USE_C89) -#define lua_strx2number(s,p) lua_str2number(s,p) -#endif - - -/* -@@ LUA_USE_AFORMAT allows '%a'/'%A' specifiers in 'string.format' -** Enable it if the C function 'printf' supports these specifiers. -** (C99 demands it and Windows also supports it.) -*/ -#if !defined(LUA_USE_C89) || defined(LUA_USE_WINDOWS) -#define LUA_USE_AFORMAT -#endif - - -/* -** 'strtof' and 'opf' variants for math functions are not valid in -** C89. Otherwise, the macro 'HUGE_VALF' is a good proxy for testing the -** availability of these variants. ('math.h' is already included in -** all files that use these macros.) -*/ -#if defined(LUA_USE_C89) || (defined(HUGE_VAL) && !defined(HUGE_VALF)) -#undef l_mathop /* variants not available */ -#undef lua_str2number -#define l_mathop(op) (lua_Number)op /* no variant */ -#define lua_str2number(s,p) ((lua_Number)strtod((s), (p))) -#endif - - -/* -@@ LUA_KCONTEXT is the type of the context ('ctx') for continuation -** functions. It must be a numerical type; Lua will use 'intptr_t' if -** available, otherwise it will use 'ptrdiff_t' (the nearest thing to -** 'intptr_t' in C89) -*/ -#define LUA_KCONTEXT ptrdiff_t - -#if !defined(LUA_USE_C89) && defined(__STDC_VERSION__) && \ - __STDC_VERSION__ >= 199901L -#include -#if defined (INTPTR_MAX) /* even in C99 this type is optional */ -#undef LUA_KCONTEXT -#define LUA_KCONTEXT intptr_t -#endif -#endif - -/* }================================================================== */ - - -/* -** {================================================================== -** Macros that affect the API and must be stable (that is, must be the -** same when you compile Lua and when you compile code that links to -** Lua). You probably do not want/need to change them. -** ===================================================================== -*/ - -/* -@@ LUAI_MAXSTACK limits the size of the Lua stack. -** CHANGE it if you need a different limit. This limit is arbitrary; -** its only purpose is to stop Lua from consuming unlimited stack -** space (and to reserve some numbers for pseudo-indices). -*/ -#if LUAI_BITSINT >= 32 -#define LUAI_MAXSTACK 1000000 -#else -#define LUAI_MAXSTACK 15000 -#endif - -/* reserve some space for error handling */ -#define LUAI_FIRSTPSEUDOIDX (-LUAI_MAXSTACK - 1000) - - -/* -@@ LUA_EXTRASPACE defines the size of a raw memory area associated with -** a Lua state with very fast access. -** CHANGE it if you need a different size. -*/ -#define LUA_EXTRASPACE (sizeof(void *)) - - -/* -@@ LUA_IDSIZE gives the maximum size for the description of the source -@@ of a function in debug information. -** CHANGE it if you want a different size. -*/ -#define LUA_IDSIZE 60 - - -/* -@@ LUAI_MAXSHORTLEN is the maximum length for short strings, that is, -** strings that are internalized. (Cannot be smaller than reserved words -** or tags for metamethods, as these strings must be internalized; -** #("function") = 8, #("__newindex") = 10.) -*/ -#define LUAI_MAXSHORTLEN 40 - - -/* -@@ LUAL_BUFFERSIZE is the buffer size used by the lauxlib buffer system. -** CHANGE it if it uses too much C-stack space. -*/ -#define LUAL_BUFFERSIZE ((int)(0x80 * sizeof(void*) * sizeof(lua_Integer))) - -/* }================================================================== */ - - -/* -@@ LUA_QL describes how error messages quote program elements. -** Lua does not use these macros anymore; they are here for -** compatibility only. -*/ -#define LUA_QL(x) "'" x "'" -#define LUA_QS LUA_QL("%s") - - - - -/* =================================================================== */ - -/* -** Local configuration. You can use this space to add your redefinitions -** without modifying the main part of the file. -*/ - - - - - -#endif - diff --git a/thirdparty/include/Lua/lualib.h b/thirdparty/include/Lua/lualib.h deleted file mode 100644 index 5165c0fb3..000000000 --- a/thirdparty/include/Lua/lualib.h +++ /dev/null @@ -1,58 +0,0 @@ -/* -** $Id: lualib.h,v 1.44 2014/02/06 17:32:33 roberto Exp $ -** Lua standard libraries -** See Copyright Notice in lua.h -*/ - - -#ifndef lualib_h -#define lualib_h - -#include "lua.h" - - - -LUAMOD_API int (luaopen_base) (lua_State *L); - -#define LUA_COLIBNAME "coroutine" -LUAMOD_API int (luaopen_coroutine) (lua_State *L); - -#define LUA_TABLIBNAME "table" -LUAMOD_API int (luaopen_table) (lua_State *L); - -#define LUA_IOLIBNAME "io" -LUAMOD_API int (luaopen_io) (lua_State *L); - -#define LUA_OSLIBNAME "os" -LUAMOD_API int (luaopen_os) (lua_State *L); - -#define LUA_STRLIBNAME "string" -LUAMOD_API int (luaopen_string) (lua_State *L); - -#define LUA_UTF8LIBNAME "utf8" -LUAMOD_API int (luaopen_utf8) (lua_State *L); - -#define LUA_BITLIBNAME "bit32" -LUAMOD_API int (luaopen_bit32) (lua_State *L); - -#define LUA_MATHLIBNAME "math" -LUAMOD_API int (luaopen_math) (lua_State *L); - -#define LUA_DBLIBNAME "debug" -LUAMOD_API int (luaopen_debug) (lua_State *L); - -#define LUA_LOADLIBNAME "package" -LUAMOD_API int (luaopen_package) (lua_State *L); - - -/* open all previous libraries */ -LUALIB_API void (luaL_openlibs) (lua_State *L); - - - -#if !defined(lua_assert) -#define lua_assert(x) ((void)0) -#endif - - -#endif diff --git a/thirdparty/include/kiwi/AssocVector.h b/thirdparty/include/kiwi/AssocVector.h deleted file mode 100644 index 2a5092416..000000000 --- a/thirdparty/include/kiwi/AssocVector.h +++ /dev/null @@ -1,356 +0,0 @@ -//////////////////////////////////////////////////////////////////////////////// -// The Loki Library -// Copyright (c) 2001 by Andrei Alexandrescu -// This code accompanies the book: -// Alexandrescu, Andrei. "Modern C++ Design: Generic Programming and Design -// Patterns Applied". Copyright (c) 2001. Addison-Wesley. -// Permission to use, copy, modify, distribute and sell this software for any -// purpose is hereby granted without fee, provided that the above copyright -// notice appear in all copies and that both that copyright notice and this -// permission notice appear in supporting documentation. -// The author or Addison-Wesley Longman make no representations about the -// suitability of this software for any purpose. It is provided "as is" -// without express or implied warranty. -//////////////////////////////////////////////////////////////////////////////// -// Updated 2019 by Matthieu Dartiailh for C++11 compliancy -//////////////////////////////////////////////////////////////////////////////// -#pragma once - -// $Id: AssocVector.h 765 2006-10-18 13:55:32Z syntheticpp $ - - -#include -#include -#include -#include - -namespace Loki -{ -//////////////////////////////////////////////////////////////////////////////// -// class template AssocVectorCompare -// Used by AssocVector -//////////////////////////////////////////////////////////////////////////////// - - namespace Private - { - template - class AssocVectorCompare : public C - { - typedef std::pair - Data; - typedef typename C::first_argument_type first_argument_type; - - public: - AssocVectorCompare() - {} - - AssocVectorCompare(const C& src) : C(src) - {} - - bool operator()(const first_argument_type& lhs, - const first_argument_type& rhs) const - { return C::operator()(lhs, rhs); } - - bool operator()(const Data& lhs, const Data& rhs) const - { return operator()(lhs.first, rhs.first); } - - bool operator()(const Data& lhs, - const first_argument_type& rhs) const - { return operator()(lhs.first, rhs); } - - bool operator()(const first_argument_type& lhs, - const Data& rhs) const - { return operator()(lhs, rhs.first); } - }; - } - -//////////////////////////////////////////////////////////////////////////////// -// class template AssocVector -// An associative vector built as a syntactic drop-in replacement for std::map -// BEWARE: AssocVector doesn't respect all map's guarantees, the most important -// being: -// * iterators are invalidated by insert and erase operations -// * the complexity of insert/erase is O(N) not O(log N) -// * value_type is std::pair not std::pair -// * iterators are random -//////////////////////////////////////////////////////////////////////////////// - - - template - < - class K, - class V, - class C = std::less, - class A = std::allocator< std::pair > - > - class AssocVector - : private std::vector< std::pair, A > - , private Private::AssocVectorCompare - { - typedef std::vector, A> Base; - typedef Private::AssocVectorCompare MyCompare; - - public: - typedef K key_type; - typedef V mapped_type; - typedef typename Base::value_type value_type; - - typedef C key_compare; - typedef A allocator_type; - typedef typename A::reference reference; - typedef typename A::const_reference const_reference; - typedef typename Base::iterator iterator; - typedef typename Base::const_iterator const_iterator; - typedef typename Base::size_type size_type; - typedef typename Base::difference_type difference_type; - typedef typename A::pointer pointer; - typedef typename A::const_pointer const_pointer; - typedef typename Base::reverse_iterator reverse_iterator; - typedef typename Base::const_reverse_iterator const_reverse_iterator; - - class value_compare - : public std::function - , private key_compare - { - friend class AssocVector; - - protected: - value_compare(key_compare pred) : key_compare(pred) - {} - - public: - bool operator()(const value_type& lhs, const value_type& rhs) const - { return key_compare::operator()(lhs.first, rhs.first); } - }; - - // 23.3.1.1 construct/copy/destroy - - explicit AssocVector(const key_compare& comp = key_compare(), - const A& alloc = A()) - : Base(alloc), MyCompare(comp) - {} - - template - AssocVector(InputIterator first, InputIterator last, - const key_compare& comp = key_compare(), - const A& alloc = A()) - : Base(first, last, alloc), MyCompare(comp) - { - MyCompare& me = *this; - std::sort(begin(), end(), me); - } - - AssocVector& operator=(const AssocVector& rhs) - { - AssocVector(rhs).swap(*this); - return *this; - } - - // iterators: - // The following are here because MWCW gets 'using' wrong - iterator begin() { return Base::begin(); } - const_iterator begin() const { return Base::begin(); } - iterator end() { return Base::end(); } - const_iterator end() const { return Base::end(); } - reverse_iterator rbegin() { return Base::rbegin(); } - const_reverse_iterator rbegin() const { return Base::rbegin(); } - reverse_iterator rend() { return Base::rend(); } - const_reverse_iterator rend() const { return Base::rend(); } - - // capacity: - bool empty() const { return Base::empty(); } - size_type size() const { return Base::size(); } - size_type max_size() { return Base::max_size(); } - - // 23.3.1.2 element access: - mapped_type& operator[](const key_type& key) - { return insert(value_type(key, mapped_type())).first->second; } - - // modifiers: - std::pair insert(const value_type& val) - { - bool found(true); - iterator i(lower_bound(val.first)); - - if (i == end() || this->operator()(val.first, i->first)) - { - i = Base::insert(i, val); - found = false; - } - return std::make_pair(i, !found); - } - //Section [23.1.2], Table 69 - //http://developer.apple.com/documentation/DeveloperTools/gcc-3.3/libstdc++/23_containers/howto.html#4 - iterator insert(iterator pos, const value_type& val) - { - if( (pos == begin() || this->operator()(*(pos-1),val)) && - (pos == end() || this->operator()(val, *pos)) ) - { - return Base::insert(pos, val); - } - return insert(val).first; - } - - template - void insert(InputIterator first, InputIterator last) - { for (; first != last; ++first) insert(*first); } - - void erase(iterator pos) - { Base::erase(pos); } - - size_type erase(const key_type& k) - { - iterator i(find(k)); - if (i == end()) return 0; - erase(i); - return 1; - } - - void erase(iterator first, iterator last) - { Base::erase(first, last); } - - void swap(AssocVector& other) - { - Base::swap(other); - MyCompare& me = *this; - MyCompare& rhs = other; - std::swap(me, rhs); - } - - void clear() - { Base::clear(); } - - // observers: - key_compare key_comp() const - { return *this; } - - value_compare value_comp() const - { - const key_compare& comp = *this; - return value_compare(comp); - } - - // 23.3.1.3 map operations: - iterator find(const key_type& k) - { - iterator i(lower_bound(k)); - if (i != end() && this->operator()(k, i->first)) - { - i = end(); - } - return i; - } - - const_iterator find(const key_type& k) const - { - const_iterator i(lower_bound(k)); - if (i != end() && this->operator()(k, i->first)) - { - i = end(); - } - return i; - } - - size_type count(const key_type& k) const - { return find(k) != end(); } - - iterator lower_bound(const key_type& k) - { - MyCompare& me = *this; - return std::lower_bound(begin(), end(), k, me); - } - - const_iterator lower_bound(const key_type& k) const - { - const MyCompare& me = *this; - return std::lower_bound(begin(), end(), k, me); - } - - iterator upper_bound(const key_type& k) - { - MyCompare& me = *this; - return std::upper_bound(begin(), end(), k, me); - } - - const_iterator upper_bound(const key_type& k) const - { - const MyCompare& me = *this; - return std::upper_bound(begin(), end(), k, me); - } - - std::pair equal_range(const key_type& k) - { - MyCompare& me = *this; - return std::equal_range(begin(), end(), k, me); - } - - std::pair equal_range( - const key_type& k) const - { - const MyCompare& me = *this; - return std::equal_range(begin(), end(), k, me); - } - - template - friend bool operator==(const AssocVector& lhs, - const AssocVector& rhs); - - bool operator<(const AssocVector& rhs) const - { - const Base& me = *this; - const Base& yo = rhs; - return me < yo; - } - - template - friend bool operator!=(const AssocVector& lhs, - const AssocVector& rhs); - - template - friend bool operator>(const AssocVector& lhs, - const AssocVector& rhs); - - template - friend bool operator>=(const AssocVector& lhs, - const AssocVector& rhs); - - template - friend bool operator<=(const AssocVector& lhs, - const AssocVector& rhs); - }; - - template - inline bool operator==(const AssocVector& lhs, - const AssocVector& rhs) - { - const std::vector, A>& me = lhs; - return me == rhs; - } - - template - inline bool operator!=(const AssocVector& lhs, - const AssocVector& rhs) - { return !(lhs == rhs); } - - template - inline bool operator>(const AssocVector& lhs, - const AssocVector& rhs) - { return rhs < lhs; } - - template - inline bool operator>=(const AssocVector& lhs, - const AssocVector& rhs) - { return !(lhs < rhs); } - - template - inline bool operator<=(const AssocVector& lhs, - const AssocVector& rhs) - { return !(rhs < lhs); } - - - // specialized algorithms: - template - void swap(AssocVector& lhs, AssocVector& rhs) - { lhs.swap(rhs); } - -} // namespace Loki diff --git a/thirdparty/include/kiwi/constraint.h b/thirdparty/include/kiwi/constraint.h deleted file mode 100644 index 9d8322b94..000000000 --- a/thirdparty/include/kiwi/constraint.h +++ /dev/null @@ -1,119 +0,0 @@ -/*----------------------------------------------------------------------------- -| Copyright (c) 2013-2017, Nucleic Development Team. -| -| Distributed under the terms of the Modified BSD License. -| -| The full license is in the file LICENSE, distributed with this software. -|----------------------------------------------------------------------------*/ -#pragma once -#include -#include -#include "expression.h" -#include "shareddata.h" -#include "strength.h" -#include "term.h" -#include "variable.h" - -namespace kiwi -{ - -enum RelationalOperator -{ - OP_LE, - OP_GE, - OP_EQ -}; - -class Constraint -{ - -public: - Constraint() : m_data(0) {} - - Constraint(const Expression &expr, - RelationalOperator op, - double strength = strength::required) : m_data(new ConstraintData(expr, op, strength)) {} - - Constraint(const Constraint &other, double strength) : m_data(new ConstraintData(other, strength)) {} - - ~Constraint() {} - - const Expression &expression() const - { - return m_data->m_expression; - } - - RelationalOperator op() const - { - return m_data->m_op; - } - - double strength() const - { - return m_data->m_strength; - } - - bool operator!() const - { - return !m_data; - } - -private: - static Expression reduce(const Expression &expr) - { - std::map vars; - typedef std::vector::const_iterator iter_t; - iter_t end = expr.terms().end(); - for (iter_t it = expr.terms().begin(); it != end; ++it) - vars[it->variable()] += it->coefficient(); - std::vector terms(vars.begin(), vars.end()); - return Expression(terms, expr.constant()); - } - - class ConstraintData : public SharedData - { - - public: - ConstraintData(const Expression &expr, - RelationalOperator op, - double strength) : SharedData(), - m_expression(reduce(expr)), - m_strength(strength::clip(strength)), - m_op(op) {} - - ConstraintData(const Constraint &other, double strength) : SharedData(), - m_expression(other.expression()), - m_strength(strength::clip(strength)), - m_op(other.op()) {} - - ~ConstraintData() {} - - Expression m_expression; - double m_strength; - RelationalOperator m_op; - - private: - ConstraintData(const ConstraintData &other); - - ConstraintData &operator=(const ConstraintData &other); - }; - - SharedDataPtr m_data; - - friend bool operator<(const Constraint &lhs, const Constraint &rhs) - { - return lhs.m_data < rhs.m_data; - } - - friend bool operator==(const Constraint &lhs, const Constraint &rhs) - { - return lhs.m_data == rhs.m_data; - } - - friend bool operator!=(const Constraint &lhs, const Constraint &rhs) - { - return lhs.m_data != rhs.m_data; - } -}; - -} // namespace kiwi diff --git a/thirdparty/include/kiwi/debug.h b/thirdparty/include/kiwi/debug.h deleted file mode 100644 index 0d86091b2..000000000 --- a/thirdparty/include/kiwi/debug.h +++ /dev/null @@ -1,200 +0,0 @@ -/*----------------------------------------------------------------------------- -| Copyright (c) 2013-2017, Nucleic Development Team. -| -| Distributed under the terms of the Modified BSD License. -| -| The full license is in the file LICENSE, distributed with this software. -|----------------------------------------------------------------------------*/ -#pragma once -#include -#include -#include -#include "constraint.h" -#include "solverimpl.h" -#include "term.h" - -namespace kiwi -{ - -namespace impl -{ - -class DebugHelper -{ - -public: - static void dump(const SolverImpl &solver, std::ostream &out) - { - out << "Objective" << std::endl; - out << "---------" << std::endl; - dump(*solver.m_objective, out); - out << std::endl; - out << "Tableau" << std::endl; - out << "-------" << std::endl; - dump(solver.m_rows, out); - out << std::endl; - out << "Infeasible" << std::endl; - out << "----------" << std::endl; - dump(solver.m_infeasible_rows, out); - out << std::endl; - out << "Variables" << std::endl; - out << "---------" << std::endl; - dump(solver.m_vars, out); - out << std::endl; - out << "Edit Variables" << std::endl; - out << "--------------" << std::endl; - dump(solver.m_edits, out); - out << std::endl; - out << "Constraints" << std::endl; - out << "-----------" << std::endl; - dump(solver.m_cns, out); - out << std::endl; - out << std::endl; - } - - static void dump(const SolverImpl::RowMap &rows, std::ostream &out) - { - typedef SolverImpl::RowMap::const_iterator iter_t; - iter_t end = rows.end(); - for (iter_t it = rows.begin(); it != end; ++it) - { - dump(it->first, out); - out << " | "; - dump(*it->second, out); - } - } - - static void dump(const std::vector &symbols, std::ostream &out) - { - typedef std::vector::const_iterator iter_t; - iter_t end = symbols.end(); - for (iter_t it = symbols.begin(); it != end; ++it) - { - dump(*it, out); - out << std::endl; - } - } - - static void dump(const SolverImpl::VarMap &vars, std::ostream &out) - { - typedef SolverImpl::VarMap::const_iterator iter_t; - iter_t end = vars.end(); - for (iter_t it = vars.begin(); it != end; ++it) - { - out << it->first.name() << " = "; - dump(it->second, out); - out << std::endl; - } - } - - static void dump(const SolverImpl::CnMap &cns, std::ostream &out) - { - typedef SolverImpl::CnMap::const_iterator iter_t; - iter_t end = cns.end(); - for (iter_t it = cns.begin(); it != end; ++it) - dump(it->first, out); - } - - static void dump(const SolverImpl::EditMap &edits, std::ostream &out) - { - typedef SolverImpl::EditMap::const_iterator iter_t; - iter_t end = edits.end(); - for (iter_t it = edits.begin(); it != end; ++it) - out << it->first.name() << std::endl; - } - - static void dump(const Row &row, std::ostream &out) - { - typedef Row::CellMap::const_iterator iter_t; - out << row.constant(); - iter_t end = row.cells().end(); - for (iter_t it = row.cells().begin(); it != end; ++it) - { - out << " + " << it->second << " * "; - dump(it->first, out); - } - out << std::endl; - } - - static void dump(const Symbol &symbol, std::ostream &out) - { - switch (symbol.type()) - { - case Symbol::Invalid: - out << "i"; - break; - case Symbol::External: - out << "v"; - break; - case Symbol::Slack: - out << "s"; - break; - case Symbol::Error: - out << "e"; - break; - case Symbol::Dummy: - out << "d"; - break; - default: - break; - } - out << symbol.id(); - } - - static void dump(const Constraint &cn, std::ostream &out) - { - typedef std::vector::const_iterator iter_t; - iter_t begin = cn.expression().terms().begin(); - iter_t end = cn.expression().terms().end(); - for (iter_t it = begin; it != end; ++it) - { - out << it->coefficient() << " * "; - out << it->variable().name() << " + "; - } - out << cn.expression().constant(); - switch (cn.op()) - { - case OP_LE: - out << " <= 0 "; - break; - case OP_GE: - out << " >= 0 "; - break; - case OP_EQ: - out << " == 0 "; - break; - default: - break; - } - out << " | strength = " << cn.strength() << std::endl; - } -}; - -} // namespace impl - -namespace debug -{ - -template -void dump(const T &value) -{ - impl::DebugHelper::dump(value, std::cout); -} - -template -void dump(const T &value, std::ostream &out) -{ - impl::DebugHelper::dump(value, out); -} - -template -std::string dumps(const T &value) -{ - std::stringstream stream; - impl::DebugHelper::dump(value, stream); - return stream.str(); -} - -} // namespace debug - -} // namespace kiwi diff --git a/thirdparty/include/kiwi/errors.h b/thirdparty/include/kiwi/errors.h deleted file mode 100644 index eb54560f4..000000000 --- a/thirdparty/include/kiwi/errors.h +++ /dev/null @@ -1,162 +0,0 @@ -/*----------------------------------------------------------------------------- -| Copyright (c) 2013-2017, Nucleic Development Team. -| -| Distributed under the terms of the Modified BSD License. -| -| The full license is in the file LICENSE, distributed with this software. -|----------------------------------------------------------------------------*/ -#pragma once -#include -#include -#include "constraint.h" -#include "variable.h" - -namespace kiwi -{ - -class UnsatisfiableConstraint : public std::exception -{ - -public: - UnsatisfiableConstraint(const Constraint &constraint) : m_constraint(constraint) {} - - ~UnsatisfiableConstraint() throw() {} - - const char *what() const throw() - { - return "The constraint can not be satisfied."; - } - - const Constraint &constraint() const - { - return m_constraint; - } - -private: - Constraint m_constraint; -}; - -class UnknownConstraint : public std::exception -{ - -public: - UnknownConstraint(const Constraint &constraint) : m_constraint(constraint) {} - - ~UnknownConstraint() throw() {} - - const char *what() const throw() - { - return "The constraint has not been added to the solver."; - } - - const Constraint &constraint() const - { - return m_constraint; - } - -private: - Constraint m_constraint; -}; - -class DuplicateConstraint : public std::exception -{ - -public: - DuplicateConstraint(const Constraint &constraint) : m_constraint(constraint) {} - - ~DuplicateConstraint() throw() {} - - const char *what() const throw() - { - return "The constraint has already been added to the solver."; - } - - const Constraint &constraint() const - { - return m_constraint; - } - -private: - Constraint m_constraint; -}; - -class UnknownEditVariable : public std::exception -{ - -public: - UnknownEditVariable(const Variable &variable) : m_variable(variable) {} - - ~UnknownEditVariable() throw() {} - - const char *what() const throw() - { - return "The edit variable has not been added to the solver."; - } - - const Variable &variable() const - { - return m_variable; - } - -private: - Variable m_variable; -}; - -class DuplicateEditVariable : public std::exception -{ - -public: - DuplicateEditVariable(const Variable &variable) : m_variable(variable) {} - - ~DuplicateEditVariable() throw() {} - - const char *what() const throw() - { - return "The edit variable has already been added to the solver."; - } - - const Variable &variable() const - { - return m_variable; - } - -private: - Variable m_variable; -}; - -class BadRequiredStrength : public std::exception -{ - -public: - BadRequiredStrength() {} - - ~BadRequiredStrength() throw() {} - - const char *what() const throw() - { - return "A required strength cannot be used in this context."; - } -}; - -class InternalSolverError : public std::exception -{ - -public: - InternalSolverError() : m_msg("An internal solver error ocurred.") {} - - InternalSolverError(const char *msg) : m_msg(msg) {} - - InternalSolverError(const std::string &msg) : m_msg(msg) {} - - ~InternalSolverError() throw() {} - - const char *what() const throw() - { - return m_msg.c_str(); - } - -private: - std::string m_msg; -}; - -} // namespace kiwi diff --git a/thirdparty/include/kiwi/expression.h b/thirdparty/include/kiwi/expression.h deleted file mode 100644 index e2b5ae668..000000000 --- a/thirdparty/include/kiwi/expression.h +++ /dev/null @@ -1,52 +0,0 @@ -/*----------------------------------------------------------------------------- -| Copyright (c) 2013-2017, Nucleic Development Team. -| -| Distributed under the terms of the Modified BSD License. -| -| The full license is in the file LICENSE, distributed with this software. -|----------------------------------------------------------------------------*/ -#pragma once -#include -#include "term.h" - -namespace kiwi -{ - -class Expression -{ - -public: - Expression(double constant = 0.0) : m_constant(constant) {} - - Expression(const Term &term, double constant = 0.0) : m_terms(1, term), m_constant(constant) {} - - Expression(const std::vector &terms, double constant = 0.0) : m_terms(terms), m_constant(constant) {} - - ~Expression() {} - - const std::vector &terms() const - { - return m_terms; - } - - double constant() const - { - return m_constant; - } - - double value() const - { - typedef std::vector::const_iterator iter_t; - double result = m_constant; - iter_t end = m_terms.end(); - for (iter_t it = m_terms.begin(); it != end; ++it) - result += it->value(); - return result; - } - -private: - std::vector m_terms; - double m_constant; -}; - -} // namespace kiwi diff --git a/thirdparty/include/kiwi/kiwi.h b/thirdparty/include/kiwi/kiwi.h deleted file mode 100644 index 77bb6a8ec..000000000 --- a/thirdparty/include/kiwi/kiwi.h +++ /dev/null @@ -1,19 +0,0 @@ -/*----------------------------------------------------------------------------- -| Copyright (c) 2013-2017, Nucleic Development Team. -| -| Distributed under the terms of the Modified BSD License. -| -| The full license is in the file LICENSE, distributed with this software. -|----------------------------------------------------------------------------*/ -#pragma once -#include "constraint.h" -#include "debug.h" -#include "errors.h" -#include "expression.h" -#include "shareddata.h" -#include "solver.h" -#include "strength.h" -#include "symbolics.h" -#include "term.h" -#include "variable.h" -#include "version.h" diff --git a/thirdparty/include/kiwi/maptype.h b/thirdparty/include/kiwi/maptype.h deleted file mode 100644 index 9b19a2173..000000000 --- a/thirdparty/include/kiwi/maptype.h +++ /dev/null @@ -1,37 +0,0 @@ -/*----------------------------------------------------------------------------- -| Copyright (c) 2013-2019, Nucleic Development Team. -| -| Distributed under the terms of the Modified BSD License. -| -| The full license is in the file LICENSE, distributed with this software. -|----------------------------------------------------------------------------*/ -#pragma once -#include -#include -#include -#include -#include "AssocVector.h" - -namespace kiwi -{ - -namespace impl -{ - -template < - typename K, - typename V, - typename C = std::less, - typename A = std::allocator>> -using MapType = Loki::AssocVector; - -// template< -// typename K, -// typename V, -// typename C = std::less, -// typename A = std::allocator< std::pair > > -// using MapType = std::map; - -} // namespace impl - -} // namespace kiwi diff --git a/thirdparty/include/kiwi/row.h b/thirdparty/include/kiwi/row.h deleted file mode 100644 index 29b25135b..000000000 --- a/thirdparty/include/kiwi/row.h +++ /dev/null @@ -1,188 +0,0 @@ -/*----------------------------------------------------------------------------- -| Copyright (c) 2013-2017, Nucleic Development Team. -| -| Distributed under the terms of the Modified BSD License. -| -| The full license is in the file LICENSE, distributed with this software. -|----------------------------------------------------------------------------*/ -#pragma once -#include "maptype.h" -#include "symbol.h" -#include "util.h" - -namespace kiwi -{ - -namespace impl -{ - -class Row -{ - -public: - typedef MapType CellMap; - - Row() : m_constant(0.0) {} - - Row(double constant) : m_constant(constant) {} - - Row(const Row &other) : m_cells(other.m_cells), m_constant(other.m_constant) {} - - ~Row() {} - - const CellMap &cells() const - { - return m_cells; - } - - double constant() const - { - return m_constant; - } - - /* Add a constant value to the row constant. - - The new value of the constant is returned. - - */ - double add(double value) - { - return m_constant += value; - } - - /* Insert a symbol into the row with a given coefficient. - - If the symbol already exists in the row, the coefficient will be - added to the existing coefficient. If the resulting coefficient - is zero, the symbol will be removed from the row. - - */ - void insert(const Symbol &symbol, double coefficient = 1.0) - { - if (nearZero(m_cells[symbol] += coefficient)) - m_cells.erase(symbol); - } - - /* Insert a row into this row with a given coefficient. - - The constant and the cells of the other row will be multiplied by - the coefficient and added to this row. Any cell with a resulting - coefficient of zero will be removed from the row. - - */ - void insert(const Row &other, double coefficient = 1.0) - { - typedef CellMap::const_iterator iter_t; - m_constant += other.m_constant * coefficient; - iter_t end = other.m_cells.end(); - for (iter_t it = other.m_cells.begin(); it != end; ++it) - { - double coeff = it->second * coefficient; - if (nearZero(m_cells[it->first] += coeff)) - m_cells.erase(it->first); - } - } - - /* Remove the given symbol from the row. - - */ - void remove(const Symbol &symbol) - { - CellMap::iterator it = m_cells.find(symbol); - if (it != m_cells.end()) - m_cells.erase(it); - } - - /* Reverse the sign of the constant and all cells in the row. - - */ - void reverseSign() - { - typedef CellMap::iterator iter_t; - m_constant = -m_constant; - iter_t end = m_cells.end(); - for (iter_t it = m_cells.begin(); it != end; ++it) - it->second = -it->second; - } - - /* Solve the row for the given symbol. - - This method assumes the row is of the form a * x + b * y + c = 0 - and (assuming solve for x) will modify the row to represent the - right hand side of x = -b/a * y - c / a. The target symbol will - be removed from the row, and the constant and other cells will - be multiplied by the negative inverse of the target coefficient. - - The given symbol *must* exist in the row. - - */ - void solveFor(const Symbol &symbol) - { - typedef CellMap::iterator iter_t; - double coeff = -1.0 / m_cells[symbol]; - m_cells.erase(symbol); - m_constant *= coeff; - iter_t end = m_cells.end(); - for (iter_t it = m_cells.begin(); it != end; ++it) - it->second *= coeff; - } - - /* Solve the row for the given symbols. - - This method assumes the row is of the form x = b * y + c and will - solve the row such that y = x / b - c / b. The rhs symbol will be - removed from the row, the lhs added, and the result divided by the - negative inverse of the rhs coefficient. - - The lhs symbol *must not* exist in the row, and the rhs symbol - *must* exist in the row. - - */ - void solveFor(const Symbol &lhs, const Symbol &rhs) - { - insert(lhs, -1.0); - solveFor(rhs); - } - - /* Get the coefficient for the given symbol. - - If the symbol does not exist in the row, zero will be returned. - - */ - double coefficientFor(const Symbol &symbol) const - { - CellMap::const_iterator it = m_cells.find(symbol); - if (it == m_cells.end()) - return 0.0; - return it->second; - } - - /* Substitute a symbol with the data from another row. - - Given a row of the form a * x + b and a substitution of the - form x = 3 * y + c the row will be updated to reflect the - expression 3 * a * y + a * c + b. - - If the symbol does not exist in the row, this is a no-op. - - */ - void substitute(const Symbol &symbol, const Row &row) - { - typedef CellMap::iterator iter_t; - iter_t it = m_cells.find(symbol); - if (it != m_cells.end()) - { - double coefficient = it->second; - m_cells.erase(it); - insert(row, coefficient); - } - } - -private: - CellMap m_cells; - double m_constant; -}; - -} // namespace impl - -} // namespace kiwi diff --git a/thirdparty/include/kiwi/shareddata.h b/thirdparty/include/kiwi/shareddata.h deleted file mode 100644 index 9b1bc2c01..000000000 --- a/thirdparty/include/kiwi/shareddata.h +++ /dev/null @@ -1,151 +0,0 @@ -/*----------------------------------------------------------------------------- -| Copyright (c) 2013-2017, Nucleic Development Team. -| -| Distributed under the terms of the Modified BSD License. -| -| The full license is in the file LICENSE, distributed with this software. -|----------------------------------------------------------------------------*/ -#pragma once - -namespace kiwi -{ - -class SharedData -{ - -public: - SharedData() : m_refcount(0) {} - - SharedData(const SharedData &other) : m_refcount(0) {} - - int m_refcount; - -private: - SharedData &operator=(const SharedData &other); -}; - -template -class SharedDataPtr -{ - -public: - typedef T Type; - - SharedDataPtr() : m_data(0) {} - - explicit SharedDataPtr(T *data) : m_data(data) - { - incref(m_data); - } - - ~SharedDataPtr() - { - decref(m_data); - } - - T *data() - { - return m_data; - } - - const T *data() const - { - return m_data; - } - - operator T *() - { - return m_data; - } - - operator const T *() const - { - return m_data; - } - - T *operator->() - { - return m_data; - } - - const T *operator->() const - { - return m_data; - } - - T &operator*() - { - return *m_data; - } - - const T &operator*() const - { - return *m_data; - } - - bool operator!() const - { - return !m_data; - } - - bool operator<(const SharedDataPtr &other) const - { - return m_data < other.m_data; - } - - bool operator==(const SharedDataPtr &other) const - { - return m_data == other.m_data; - } - - bool operator!=(const SharedDataPtr &other) const - { - return m_data != other.m_data; - } - - SharedDataPtr(const SharedDataPtr &other) : m_data(other.m_data) - { - incref(m_data); - } - - SharedDataPtr &operator=(const SharedDataPtr &other) - { - if (m_data != other.m_data) - { - T *temp = m_data; - m_data = other.m_data; - incref(m_data); - decref(temp); - } - return *this; - } - - SharedDataPtr &operator=(T *other) - { - if (m_data != other) - { - T *temp = m_data; - m_data = other; - incref(m_data); - decref(temp); - } - return *this; - } - -private: - static void incref(T *data) - { - if (data) - ++data->m_refcount; - } - - static void decref(T *data) - { - if (data && --data->m_refcount == 0) - delete data; - } - - T *m_data; -}; - -} // namespace kiwi diff --git a/thirdparty/include/kiwi/solver.h b/thirdparty/include/kiwi/solver.h deleted file mode 100644 index 678df8ac7..000000000 --- a/thirdparty/include/kiwi/solver.h +++ /dev/null @@ -1,178 +0,0 @@ -/*----------------------------------------------------------------------------- -| Copyright (c) 2013-2017, Nucleic Development Team. -| -| Distributed under the terms of the Modified BSD License. -| -| The full license is in the file LICENSE, distributed with this software. -|----------------------------------------------------------------------------*/ -#pragma once -#include "constraint.h" -#include "debug.h" -#include "solverimpl.h" -#include "strength.h" -#include "variable.h" - - -namespace kiwi -{ - -class Solver -{ - -public: - - Solver() {} - - ~Solver() {} - - /* Add a constraint to the solver. - - Throws - ------ - DuplicateConstraint - The given constraint has already been added to the solver. - - UnsatisfiableConstraint - The given constraint is required and cannot be satisfied. - - */ - void addConstraint( const Constraint& constraint ) - { - m_impl.addConstraint( constraint ); - } - - /* Remove a constraint from the solver. - - Throws - ------ - UnknownConstraint - The given constraint has not been added to the solver. - - */ - void removeConstraint( const Constraint& constraint ) - { - m_impl.removeConstraint( constraint ); - } - - /* Test whether a constraint has been added to the solver. - - */ - bool hasConstraint( const Constraint& constraint ) const - { - return m_impl.hasConstraint( constraint ); - } - - /* Add an edit variable to the solver. - - This method should be called before the `suggestValue` method is - used to supply a suggested value for the given edit variable. - - Throws - ------ - DuplicateEditVariable - The given edit variable has already been added to the solver. - - BadRequiredStrength - The given strength is >= required. - - */ - void addEditVariable( const Variable& variable, double strength ) - { - m_impl.addEditVariable( variable, strength ); - } - - /* Remove an edit variable from the solver. - - Throws - ------ - UnknownEditVariable - The given edit variable has not been added to the solver. - - */ - void removeEditVariable( const Variable& variable ) - { - m_impl.removeEditVariable( variable ); - } - - /* Test whether an edit variable has been added to the solver. - - */ - bool hasEditVariable( const Variable& variable ) const - { - return m_impl.hasEditVariable( variable ); - } - - /* Suggest a value for the given edit variable. - - This method should be used after an edit variable as been added to - the solver in order to suggest the value for that variable. After - all suggestions have been made, the `solve` method can be used to - update the values of all variables. - - Throws - ------ - UnknownEditVariable - The given edit variable has not been added to the solver. - - */ - void suggestValue( const Variable& variable, double value ) - { - m_impl.suggestValue( variable, value ); - } - - /* Update the values of the external solver variables. - - */ - void updateVariables() - { - m_impl.updateVariables(); - } - - /* Reset the solver to the empty starting condition. - - This method resets the internal solver state to the empty starting - condition, as if no constraints or edit variables have been added. - This can be faster than deleting the solver and creating a new one - when the entire system must change, since it can avoid unecessary - heap (de)allocations. - - */ - void reset() - { - m_impl.reset(); - } - - /* Dump a representation of the solver internals to stdout. - - */ - void dump() - { - debug::dump( m_impl ); - } - - /* Dump a representation of the solver internals to a stream. - - */ - void dump( std::ostream& out ) - { - debug::dump( m_impl, out ); - } - - /* Dump a representation of the solver internals to a string. - - */ - std::string dumps() - { - return debug::dumps( m_impl ); - } - -private: - - Solver( const Solver& ); - - Solver& operator=( const Solver& ); - - impl::SolverImpl m_impl; -}; - -} // namespace kiwi diff --git a/thirdparty/include/kiwi/solverimpl.h b/thirdparty/include/kiwi/solverimpl.h deleted file mode 100644 index bb6690aeb..000000000 --- a/thirdparty/include/kiwi/solverimpl.h +++ /dev/null @@ -1,840 +0,0 @@ -/*----------------------------------------------------------------------------- -| Copyright (c) 2013-2017, Nucleic Development Team. -| -| Distributed under the terms of the Modified BSD License. -| -| The full license is in the file LICENSE, distributed with this software. -|----------------------------------------------------------------------------*/ -#pragma once -#include -#include -#include -#include -#include "constraint.h" -#include "errors.h" -#include "expression.h" -#include "maptype.h" -#include "row.h" -#include "symbol.h" -#include "term.h" -#include "util.h" -#include "variable.h" - - -namespace kiwi -{ - -namespace impl -{ - -class SolverImpl -{ - friend class DebugHelper; - - struct Tag - { - Symbol marker; - Symbol other; - }; - - struct EditInfo - { - Tag tag; - Constraint constraint; - double constant; - }; - - typedef MapType VarMap; - - typedef MapType RowMap; - - typedef MapType CnMap; - - typedef MapType EditMap; - - struct DualOptimizeGuard - { - DualOptimizeGuard( SolverImpl& impl ) : m_impl( impl ) {} - ~DualOptimizeGuard() { m_impl.dualOptimize(); } - SolverImpl& m_impl; - }; - -public: - - SolverImpl() : m_objective( new Row() ), m_id_tick( 1 ) {} - - ~SolverImpl() { clearRows(); } - - /* Add a constraint to the solver. - - Throws - ------ - DuplicateConstraint - The given constraint has already been added to the solver. - - UnsatisfiableConstraint - The given constraint is required and cannot be satisfied. - - */ - void addConstraint( const Constraint& constraint ) - { - if( m_cns.find( constraint ) != m_cns.end() ) - throw DuplicateConstraint( constraint ); - - // Creating a row causes symbols to be reserved for the variables - // in the constraint. If this method exits with an exception, - // then its possible those variables will linger in the var map. - // Since its likely that those variables will be used in other - // constraints and since exceptional conditions are uncommon, - // i'm not too worried about aggressive cleanup of the var map. - Tag tag; - std::unique_ptr rowptr( createRow( constraint, tag ) ); - Symbol subject( chooseSubject( *rowptr, tag ) ); - - // If chooseSubject could not find a valid entering symbol, one - // last option is available if the entire row is composed of - // dummy variables. If the constant of the row is zero, then - // this represents redundant constraints and the new dummy - // marker can enter the basis. If the constant is non-zero, - // then it represents an unsatisfiable constraint. - if( subject.type() == Symbol::Invalid && allDummies( *rowptr ) ) - { - if( !nearZero( rowptr->constant() ) ) - throw UnsatisfiableConstraint( constraint ); - else - subject = tag.marker; - } - - // If an entering symbol still isn't found, then the row must - // be added using an artificial variable. If that fails, then - // the row represents an unsatisfiable constraint. - if( subject.type() == Symbol::Invalid ) - { - if( !addWithArtificialVariable( *rowptr ) ) - throw UnsatisfiableConstraint( constraint ); - } - else - { - rowptr->solveFor( subject ); - substitute( subject, *rowptr ); - m_rows[ subject ] = rowptr.release(); - } - - m_cns[ constraint ] = tag; - - // Optimizing after each constraint is added performs less - // aggregate work due to a smaller average system size. It - // also ensures the solver remains in a consistent state. - optimize( *m_objective ); - } - - /* Remove a constraint from the solver. - - Throws - ------ - UnknownConstraint - The given constraint has not been added to the solver. - - */ - void removeConstraint( const Constraint& constraint ) - { - CnMap::iterator cn_it = m_cns.find( constraint ); - if( cn_it == m_cns.end() ) - throw UnknownConstraint( constraint ); - - Tag tag( cn_it->second ); - m_cns.erase( cn_it ); - - // Remove the error effects from the objective function - // *before* pivoting, or substitutions into the objective - // will lead to incorrect solver results. - removeConstraintEffects( constraint, tag ); - - // If the marker is basic, simply drop the row. Otherwise, - // pivot the marker into the basis and then drop the row. - RowMap::iterator row_it = m_rows.find( tag.marker ); - if( row_it != m_rows.end() ) - { - std::unique_ptr rowptr( row_it->second ); - m_rows.erase( row_it ); - } - else - { - row_it = getMarkerLeavingRow( tag.marker ); - if( row_it == m_rows.end() ) - throw InternalSolverError( "failed to find leaving row" ); - Symbol leaving( row_it->first ); - std::unique_ptr rowptr( row_it->second ); - m_rows.erase( row_it ); - rowptr->solveFor( leaving, tag.marker ); - substitute( tag.marker, *rowptr ); - } - - // Optimizing after each constraint is removed ensures that the - // solver remains consistent. It makes the solver api easier to - // use at a small tradeoff for speed. - optimize( *m_objective ); - } - - /* Test whether a constraint has been added to the solver. - - */ - bool hasConstraint( const Constraint& constraint ) const - { - return m_cns.find( constraint ) != m_cns.end(); - } - - /* Add an edit variable to the solver. - - This method should be called before the `suggestValue` method is - used to supply a suggested value for the given edit variable. - - Throws - ------ - DuplicateEditVariable - The given edit variable has already been added to the solver. - - BadRequiredStrength - The given strength is >= required. - - */ - void addEditVariable( const Variable& variable, double strength ) - { - if( m_edits.find( variable ) != m_edits.end() ) - throw DuplicateEditVariable( variable ); - strength = strength::clip( strength ); - if( strength == strength::required ) - throw BadRequiredStrength(); - Constraint cn( Expression( variable ), OP_EQ, strength ); - addConstraint( cn ); - EditInfo info; - info.tag = m_cns[ cn ]; - info.constraint = cn; - info.constant = 0.0; - m_edits[ variable ] = info; - } - - /* Remove an edit variable from the solver. - - Throws - ------ - UnknownEditVariable - The given edit variable has not been added to the solver. - - */ - void removeEditVariable( const Variable& variable ) - { - EditMap::iterator it = m_edits.find( variable ); - if( it == m_edits.end() ) - throw UnknownEditVariable( variable ); - removeConstraint( it->second.constraint ); - m_edits.erase( it ); - } - - /* Test whether an edit variable has been added to the solver. - - */ - bool hasEditVariable( const Variable& variable ) const - { - return m_edits.find( variable ) != m_edits.end(); - } - - /* Suggest a value for the given edit variable. - - This method should be used after an edit variable as been added to - the solver in order to suggest the value for that variable. - - Throws - ------ - UnknownEditVariable - The given edit variable has not been added to the solver. - - */ - void suggestValue( const Variable& variable, double value ) - { - EditMap::iterator it = m_edits.find( variable ); - if( it == m_edits.end() ) - throw UnknownEditVariable( variable ); - - DualOptimizeGuard guard( *this ); - EditInfo& info = it->second; - double delta = value - info.constant; - info.constant = value; - - // Check first if the positive error variable is basic. - RowMap::iterator row_it = m_rows.find( info.tag.marker ); - if( row_it != m_rows.end() ) - { - if( row_it->second->add( -delta ) < 0.0 ) - m_infeasible_rows.push_back( row_it->first ); - return; - } - - // Check next if the negative error variable is basic. - row_it = m_rows.find( info.tag.other ); - if( row_it != m_rows.end() ) - { - if( row_it->second->add( delta ) < 0.0 ) - m_infeasible_rows.push_back( row_it->first ); - return; - } - - // Otherwise update each row where the error variables exist. - RowMap::iterator end = m_rows.end(); - for( row_it = m_rows.begin(); row_it != end; ++row_it ) - { - double coeff = row_it->second->coefficientFor( info.tag.marker ); - if( coeff != 0.0 && - row_it->second->add( delta * coeff ) < 0.0 && - row_it->first.type() != Symbol::External ) - m_infeasible_rows.push_back( row_it->first ); - } - } - - /* Update the values of the external solver variables. - - */ - void updateVariables() - { - typedef RowMap::iterator row_iter_t; - typedef VarMap::iterator var_iter_t; - row_iter_t row_end = m_rows.end(); - var_iter_t var_end = m_vars.end(); - for( var_iter_t var_it = m_vars.begin(); var_it != var_end; ++var_it ) - { - Variable& var( const_cast( var_it->first ) ); - row_iter_t row_it = m_rows.find( var_it->second ); - if( row_it == row_end ) - var.setValue( 0.0 ); - else - var.setValue( row_it->second->constant() ); - } - } - - /* Reset the solver to the empty starting condition. - - This method resets the internal solver state to the empty starting - condition, as if no constraints or edit variables have been added. - This can be faster than deleting the solver and creating a new one - when the entire system must change, since it can avoid unecessary - heap (de)allocations. - - */ - void reset() - { - clearRows(); - m_cns.clear(); - m_vars.clear(); - m_edits.clear(); - m_infeasible_rows.clear(); - m_objective.reset( new Row() ); - m_artificial.reset(); - m_id_tick = 1; - } - -private: - - SolverImpl( const SolverImpl& ); - - SolverImpl& operator=( const SolverImpl& ); - - struct RowDeleter - { - template - void operator()( T& pair ) { delete pair.second; } - }; - - void clearRows() - { - std::for_each( m_rows.begin(), m_rows.end(), RowDeleter() ); - m_rows.clear(); - } - - /* Get the symbol for the given variable. - - If a symbol does not exist for the variable, one will be created. - - */ - Symbol getVarSymbol( const Variable& variable ) - { - VarMap::iterator it = m_vars.find( variable ); - if( it != m_vars.end() ) - return it->second; - Symbol symbol( Symbol::External, m_id_tick++ ); - m_vars[ variable ] = symbol; - return symbol; - } - - /* Create a new Row object for the given constraint. - - The terms in the constraint will be converted to cells in the row. - Any term in the constraint with a coefficient of zero is ignored. - This method uses the `getVarSymbol` method to get the symbol for - the variables added to the row. If the symbol for a given cell - variable is basic, the cell variable will be substituted with the - basic row. - - The necessary slack and error variables will be added to the row. - If the constant for the row is negative, the sign for the row - will be inverted so the constant becomes positive. - - The tag will be updated with the marker and error symbols to use - for tracking the movement of the constraint in the tableau. - - */ - Row* createRow( const Constraint& constraint, Tag& tag ) - { - typedef std::vector::const_iterator iter_t; - const Expression& expr( constraint.expression() ); - Row* row = new Row( expr.constant() ); - - // Substitute the current basic variables into the row. - iter_t end = expr.terms().end(); - for( iter_t it = expr.terms().begin(); it != end; ++it ) - { - if( !nearZero( it->coefficient() ) ) - { - Symbol symbol( getVarSymbol( it->variable() ) ); - RowMap::const_iterator row_it = m_rows.find( symbol ); - if( row_it != m_rows.end() ) - row->insert( *row_it->second, it->coefficient() ); - else - row->insert( symbol, it->coefficient() ); - } - } - - // Add the necessary slack, error, and dummy variables. - switch( constraint.op() ) - { - case OP_LE: - case OP_GE: - { - double coeff = constraint.op() == OP_LE ? 1.0 : -1.0; - Symbol slack( Symbol::Slack, m_id_tick++ ); - tag.marker = slack; - row->insert( slack, coeff ); - if( constraint.strength() < strength::required ) - { - Symbol error( Symbol::Error, m_id_tick++ ); - tag.other = error; - row->insert( error, -coeff ); - m_objective->insert( error, constraint.strength() ); - } - break; - } - case OP_EQ: - { - if( constraint.strength() < strength::required ) - { - Symbol errplus( Symbol::Error, m_id_tick++ ); - Symbol errminus( Symbol::Error, m_id_tick++ ); - tag.marker = errplus; - tag.other = errminus; - row->insert( errplus, -1.0 ); // v = eplus - eminus - row->insert( errminus, 1.0 ); // v - eplus + eminus = 0 - m_objective->insert( errplus, constraint.strength() ); - m_objective->insert( errminus, constraint.strength() ); - } - else - { - Symbol dummy( Symbol::Dummy, m_id_tick++ ); - tag.marker = dummy; - row->insert( dummy ); - } - break; - } - } - - // Ensure the row as a positive constant. - if( row->constant() < 0.0 ) - row->reverseSign(); - - return row; - } - - /* Choose the subject for solving for the row. - - This method will choose the best subject for using as the solve - target for the row. An invalid symbol will be returned if there - is no valid target. - - The symbols are chosen according to the following precedence: - - 1) The first symbol representing an external variable. - 2) A negative slack or error tag variable. - - If a subject cannot be found, an invalid symbol will be returned. - - */ - Symbol chooseSubject( const Row& row, const Tag& tag ) - { - typedef Row::CellMap::const_iterator iter_t; - iter_t end = row.cells().end(); - for( iter_t it = row.cells().begin(); it != end; ++it ) - { - if( it->first.type() == Symbol::External ) - return it->first; - } - if( tag.marker.type() == Symbol::Slack || tag.marker.type() == Symbol::Error ) - { - if( row.coefficientFor( tag.marker ) < 0.0 ) - return tag.marker; - } - if( tag.other.type() == Symbol::Slack || tag.other.type() == Symbol::Error ) - { - if( row.coefficientFor( tag.other ) < 0.0 ) - return tag.other; - } - return Symbol(); - } - - /* Add the row to the tableau using an artificial variable. - - This will return false if the constraint cannot be satisfied. - - */ - bool addWithArtificialVariable( const Row& row ) - { - // Create and add the artificial variable to the tableau - Symbol art( Symbol::Slack, m_id_tick++ ); - m_rows[ art ] = new Row( row ); - m_artificial.reset( new Row( row ) ); - - // Optimize the artificial objective. This is successful - // only if the artificial objective is optimized to zero. - optimize( *m_artificial ); - bool success = nearZero( m_artificial->constant() ); - m_artificial.reset(); - - // If the artificial variable is not basic, pivot the row so that - // it becomes basic. If the row is constant, exit early. - RowMap::iterator it = m_rows.find( art ); - if( it != m_rows.end() ) - { - std::unique_ptr rowptr( it->second ); - m_rows.erase( it ); - if( rowptr->cells().empty() ) - return success; - Symbol entering( anyPivotableSymbol( *rowptr ) ); - if( entering.type() == Symbol::Invalid ) - return false; // unsatisfiable (will this ever happen?) - rowptr->solveFor( art, entering ); - substitute( entering, *rowptr ); - m_rows[ entering ] = rowptr.release(); - } - - // Remove the artificial variable from the tableau. - RowMap::iterator end = m_rows.end(); - for( it = m_rows.begin(); it != end; ++it ) - it->second->remove( art ); - m_objective->remove( art ); - return success; - } - - /* Substitute the parametric symbol with the given row. - - This method will substitute all instances of the parametric symbol - in the tableau and the objective function with the given row. - - */ - void substitute( const Symbol& symbol, const Row& row ) - { - typedef RowMap::iterator iter_t; - iter_t end = m_rows.end(); - for( iter_t it = m_rows.begin(); it != end; ++it ) - { - it->second->substitute( symbol, row ); - if( it->first.type() != Symbol::External && - it->second->constant() < 0.0 ) - m_infeasible_rows.push_back( it->first ); - } - m_objective->substitute( symbol, row ); - if( m_artificial.get() ) - m_artificial->substitute( symbol, row ); - } - - /* Optimize the system for the given objective function. - - This method performs iterations of Phase 2 of the simplex method - until the objective function reaches a minimum. - - Throws - ------ - InternalSolverError - The value of the objective function is unbounded. - - */ - void optimize( const Row& objective ) - { - while( true ) - { - Symbol entering( getEnteringSymbol( objective ) ); - if( entering.type() == Symbol::Invalid ) - return; - RowMap::iterator it = getLeavingRow( entering ); - if( it == m_rows.end() ) - throw InternalSolverError( "The objective is unbounded." ); - // pivot the entering symbol into the basis - Symbol leaving( it->first ); - Row* row = it->second; - m_rows.erase( it ); - row->solveFor( leaving, entering ); - substitute( entering, *row ); - m_rows[ entering ] = row; - } - } - - /* Optimize the system using the dual of the simplex method. - - The current state of the system should be such that the objective - function is optimal, but not feasible. This method will perform - an iteration of the dual simplex method to make the solution both - optimal and feasible. - - Throws - ------ - InternalSolverError - The system cannot be dual optimized. - - */ - void dualOptimize() - { - while( !m_infeasible_rows.empty() ) - { - - Symbol leaving( m_infeasible_rows.back() ); - m_infeasible_rows.pop_back(); - RowMap::iterator it = m_rows.find( leaving ); - if( it != m_rows.end() && !nearZero( it->second->constant() ) && - it->second->constant() < 0.0 ) - { - Symbol entering( getDualEnteringSymbol( *it->second ) ); - if( entering.type() == Symbol::Invalid ) - throw InternalSolverError( "Dual optimize failed." ); - // pivot the entering symbol into the basis - Row* row = it->second; - m_rows.erase( it ); - row->solveFor( leaving, entering ); - substitute( entering, *row ); - m_rows[ entering ] = row; - } - } - } - - /* Compute the entering variable for a pivot operation. - - This method will return first symbol in the objective function which - is non-dummy and has a coefficient less than zero. If no symbol meets - the criteria, it means the objective function is at a minimum, and an - invalid symbol is returned. - - */ - Symbol getEnteringSymbol( const Row& objective ) - { - typedef Row::CellMap::const_iterator iter_t; - iter_t end = objective.cells().end(); - for( iter_t it = objective.cells().begin(); it != end; ++it ) - { - if( it->first.type() != Symbol::Dummy && it->second < 0.0 ) - return it->first; - } - return Symbol(); - } - - /* Compute the entering symbol for the dual optimize operation. - - This method will return the symbol in the row which has a positive - coefficient and yields the minimum ratio for its respective symbol - in the objective function. The provided row *must* be infeasible. - If no symbol is found which meats the criteria, an invalid symbol - is returned. - - */ - Symbol getDualEnteringSymbol( const Row& row ) - { - typedef Row::CellMap::const_iterator iter_t; - Symbol entering; - double ratio = std::numeric_limits::max(); - iter_t end = row.cells().end(); - for( iter_t it = row.cells().begin(); it != end; ++it ) - { - if( it->second > 0.0 && it->first.type() != Symbol::Dummy ) - { - double coeff = m_objective->coefficientFor( it->first ); - double r = coeff / it->second; - if( r < ratio ) - { - ratio = r; - entering = it->first; - } - } - } - return entering; - } - - /* Get the first Slack or Error symbol in the row. - - If no such symbol is present, and Invalid symbol will be returned. - - */ - Symbol anyPivotableSymbol( const Row& row ) - { - typedef Row::CellMap::const_iterator iter_t; - iter_t end = row.cells().end(); - for( iter_t it = row.cells().begin(); it != end; ++it ) - { - const Symbol& sym( it->first ); - if( sym.type() == Symbol::Slack || sym.type() == Symbol::Error ) - return sym; - } - return Symbol(); - } - - /* Compute the row which holds the exit symbol for a pivot. - - This method will return an iterator to the row in the row map - which holds the exit symbol. If no appropriate exit symbol is - found, the end() iterator will be returned. This indicates that - the objective function is unbounded. - - */ - RowMap::iterator getLeavingRow( const Symbol& entering ) - { - typedef RowMap::iterator iter_t; - double ratio = std::numeric_limits::max(); - iter_t end = m_rows.end(); - iter_t found = m_rows.end(); - for( iter_t it = m_rows.begin(); it != end; ++it ) - { - if( it->first.type() != Symbol::External ) - { - double temp = it->second->coefficientFor( entering ); - if( temp < 0.0 ) - { - double temp_ratio = -it->second->constant() / temp; - if( temp_ratio < ratio ) - { - ratio = temp_ratio; - found = it; - } - } - } - } - return found; - } - - /* Compute the leaving row for a marker variable. - - This method will return an iterator to the row in the row map - which holds the given marker variable. The row will be chosen - according to the following precedence: - - 1) The row with a restricted basic varible and a negative coefficient - for the marker with the smallest ratio of -constant / coefficient. - - 2) The row with a restricted basic variable and the smallest ratio - of constant / coefficient. - - 3) The last unrestricted row which contains the marker. - - If the marker does not exist in any row, the row map end() iterator - will be returned. This indicates an internal solver error since - the marker *should* exist somewhere in the tableau. - - */ - RowMap::iterator getMarkerLeavingRow( const Symbol& marker ) - { - const double dmax = std::numeric_limits::max(); - typedef RowMap::iterator iter_t; - double r1 = dmax; - double r2 = dmax; - iter_t end = m_rows.end(); - iter_t first = end; - iter_t second = end; - iter_t third = end; - for( iter_t it = m_rows.begin(); it != end; ++it ) - { - double c = it->second->coefficientFor( marker ); - if( c == 0.0 ) - continue; - if( it->first.type() == Symbol::External ) - { - third = it; - } - else if( c < 0.0 ) - { - double r = -it->second->constant() / c; - if( r < r1 ) - { - r1 = r; - first = it; - } - } - else - { - double r = it->second->constant() / c; - if( r < r2 ) - { - r2 = r; - second = it; - } - } - } - if( first != end ) - return first; - if( second != end ) - return second; - return third; - } - - /* Remove the effects of a constraint on the objective function. - - */ - void removeConstraintEffects( const Constraint& cn, const Tag& tag ) - { - if( tag.marker.type() == Symbol::Error ) - removeMarkerEffects( tag.marker, cn.strength() ); - if( tag.other.type() == Symbol::Error ) - removeMarkerEffects( tag.other, cn.strength() ); - } - - /* Remove the effects of an error marker on the objective function. - - */ - void removeMarkerEffects( const Symbol& marker, double strength ) - { - RowMap::iterator row_it = m_rows.find( marker ); - if( row_it != m_rows.end() ) - m_objective->insert( *row_it->second, -strength ); - else - m_objective->insert( marker, -strength ); - } - - /* Test whether a row is composed of all dummy variables. - - */ - bool allDummies( const Row& row ) - { - typedef Row::CellMap::const_iterator iter_t; - iter_t end = row.cells().end(); - for( iter_t it = row.cells().begin(); it != end; ++it ) - { - if( it->first.type() != Symbol::Dummy ) - return false; - } - return true; - } - - CnMap m_cns; - RowMap m_rows; - VarMap m_vars; - EditMap m_edits; - std::vector m_infeasible_rows; - std::unique_ptr m_objective; - std::unique_ptr m_artificial; - Symbol::Id m_id_tick; -}; - -} // namespace impl - -} // namespace kiwi diff --git a/thirdparty/include/kiwi/strength.h b/thirdparty/include/kiwi/strength.h deleted file mode 100644 index 11732e98f..000000000 --- a/thirdparty/include/kiwi/strength.h +++ /dev/null @@ -1,44 +0,0 @@ -/*----------------------------------------------------------------------------- -| Copyright (c) 2013-2017, Nucleic Development Team. -| -| Distributed under the terms of the Modified BSD License. -| -| The full license is in the file LICENSE, distributed with this software. -|----------------------------------------------------------------------------*/ -#pragma once -#include - - -namespace kiwi -{ - -namespace strength -{ - -inline double create( double a, double b, double c, double w = 1.0 ) -{ - double result = 0.0; - result += std::max( 0.0, std::min( 1000.0, a * w ) ) * 1000000.0; - result += std::max( 0.0, std::min( 1000.0, b * w ) ) * 1000.0; - result += std::max( 0.0, std::min( 1000.0, c * w ) ); - return result; -} - - -const double required = create( 1000.0, 1000.0, 1000.0 ); - -const double strong = create( 1.0, 0.0, 0.0 ); - -const double medium = create( 0.0, 1.0, 0.0 ); - -const double weak = create( 0.0, 0.0, 1.0 ); - - -inline double clip( double value ) -{ - return std::max( 0.0, std::min( required, value ) ); -} - -} // namespace strength - -} // namespace kiwi diff --git a/thirdparty/include/kiwi/symbol.h b/thirdparty/include/kiwi/symbol.h deleted file mode 100644 index ec422ad12..000000000 --- a/thirdparty/include/kiwi/symbol.h +++ /dev/null @@ -1,68 +0,0 @@ -/*----------------------------------------------------------------------------- -| Copyright (c) 2013-2017, Nucleic Development Team. -| -| Distributed under the terms of the Modified BSD License. -| -| The full license is in the file LICENSE, distributed with this software. -|----------------------------------------------------------------------------*/ -#pragma once - - -namespace kiwi -{ - -namespace impl -{ - -class Symbol -{ - -public: - - typedef unsigned long long Id; - - enum Type - { - Invalid, - External, - Slack, - Error, - Dummy - }; - - Symbol() : m_id( 0 ), m_type( Invalid ) {} - - Symbol( Type type, Id id ) : m_id( id ), m_type( type ) {} - - ~Symbol() {} - - Id id() const - { - return m_id; - } - - Type type() const - { - return m_type; - } - -private: - - Id m_id; - Type m_type; - - friend bool operator<( const Symbol& lhs, const Symbol& rhs ) - { - return lhs.m_id < rhs.m_id; - } - - friend bool operator==( const Symbol& lhs, const Symbol& rhs ) - { - return lhs.m_id == rhs.m_id; - } - -}; - -} // namespace impl - -} // namespace kiwi diff --git a/thirdparty/include/kiwi/symbolics.h b/thirdparty/include/kiwi/symbolics.h deleted file mode 100644 index 23eed60f5..000000000 --- a/thirdparty/include/kiwi/symbolics.h +++ /dev/null @@ -1,685 +0,0 @@ -/*----------------------------------------------------------------------------- -| Copyright (c) 2013-2017, Nucleic Development Team. -| -| Distributed under the terms of the Modified BSD License. -| -| The full license is in the file LICENSE, distributed with this software. -|----------------------------------------------------------------------------*/ -#pragma once -#include -#include "constraint.h" -#include "expression.h" -#include "term.h" -#include "variable.h" - - -namespace kiwi -{ - -// Variable multiply, divide, and unary invert - -inline -Term operator*( const Variable& variable, double coefficient ) -{ - return Term( variable, coefficient ); -} - - -inline -Term operator/( const Variable& variable, double denominator ) -{ - return variable * ( 1.0 / denominator ); -} - - -inline -Term operator-( const Variable& variable ) -{ - return variable * -1.0; -} - - -// Term multiply, divide, and unary invert - -inline -Term operator*( const Term& term, double coefficient ) -{ - return Term( term.variable(), term.coefficient() * coefficient ); -} - - -inline -Term operator/( const Term& term, double denominator ) -{ - return term * ( 1.0 / denominator ); -} - - -inline -Term operator-( const Term& term ) -{ - return term * -1.0; -} - - -// Expression multiply, divide, and unary invert - -inline -Expression operator*( const Expression& expression, double coefficient ) -{ - std::vector terms; - terms.reserve( expression.terms().size() ); - typedef std::vector::const_iterator iter_t; - iter_t begin = expression.terms().begin(); - iter_t end = expression.terms().end(); - for( iter_t it = begin; it != end; ++it ) - terms.push_back( ( *it ) * coefficient ); - return Expression( terms, expression.constant() * coefficient ); -} - - -inline -Expression operator/( const Expression& expression, double denominator ) -{ - return expression * ( 1.0 / denominator ); -} - - -inline -Expression operator-( const Expression& expression ) -{ - return expression * -1.0; -} - - -// Double multiply - -inline -Expression operator*( double coefficient, const Expression& expression ) -{ - return expression * coefficient; -} - - -inline -Term operator*( double coefficient, const Term& term ) -{ - return term * coefficient; -} - - -inline -Term operator*( double coefficient, const Variable& variable ) -{ - return variable * coefficient; -} - - -// Expression add and subtract - -inline -Expression operator+( const Expression& first, const Expression& second ) -{ - std::vector terms; - terms.reserve( first.terms().size() + second.terms().size() ); - terms.insert( terms.begin(), first.terms().begin(), first.terms().end() ); - terms.insert( terms.end(), second.terms().begin(), second.terms().end() ); - return Expression( terms, first.constant() + second.constant() ); -} - - -inline -Expression operator+( const Expression& first, const Term& second ) -{ - std::vector terms; - terms.reserve( first.terms().size() + 1 ); - terms.insert( terms.begin(), first.terms().begin(), first.terms().end() ); - terms.push_back( second ); - return Expression( terms, first.constant() ); -} - - -inline -Expression operator+( const Expression& expression, const Variable& variable ) -{ - return expression + Term( variable ); -} - - -inline -Expression operator+( const Expression& expression, double constant ) -{ - return Expression( expression.terms(), expression.constant() + constant ); -} - - -inline -Expression operator-( const Expression& first, const Expression& second ) -{ - return first + -second; -} - - -inline -Expression operator-( const Expression& expression, const Term& term ) -{ - return expression + -term; -} - - -inline -Expression operator-( const Expression& expression, const Variable& variable ) -{ - return expression + -variable; -} - - -inline -Expression operator-( const Expression& expression, double constant ) -{ - return expression + -constant; -} - - -// Term add and subtract - -inline -Expression operator+( const Term& term, const Expression& expression ) -{ - return expression + term; -} - - -inline -Expression operator+( const Term& first, const Term& second ) -{ - std::vector terms; - terms.reserve( 2 ); - terms.push_back( first ); - terms.push_back( second ); - return Expression( terms ); -} - - -inline -Expression operator+( const Term& term, const Variable& variable ) -{ - return term + Term( variable ); -} - - -inline -Expression operator+( const Term& term, double constant ) -{ - return Expression( term, constant ); -} - - -inline -Expression operator-( const Term& term, const Expression& expression ) -{ - return -expression + term; -} - - -inline -Expression operator-( const Term& first, const Term& second ) -{ - return first + -second; -} - - -inline -Expression operator-( const Term& term, const Variable& variable ) -{ - return term + -variable; -} - - -inline -Expression operator-( const Term& term, double constant ) -{ - return term + -constant; -} - - -// Variable add and subtract - -inline -Expression operator+( const Variable& variable, const Expression& expression ) -{ - return expression + variable; -} - - -inline -Expression operator+( const Variable& variable, const Term& term ) -{ - return term + variable; -} - - -inline -Expression operator+( const Variable& first, const Variable& second ) -{ - return Term( first ) + second; -} - - -inline -Expression operator+( const Variable& variable, double constant ) -{ - return Term( variable ) + constant; -} - - -inline -Expression operator-( const Variable& variable, const Expression& expression ) -{ - return variable + -expression; -} - - -inline -Expression operator-( const Variable& variable, const Term& term ) -{ - return variable + -term; -} - - -inline -Expression operator-( const Variable& first, const Variable& second ) -{ - return first + -second; -} - - -inline -Expression operator-( const Variable& variable, double constant ) -{ - return variable + -constant; -} - - -// Double add and subtract - -inline -Expression operator+( double constant, const Expression& expression ) -{ - return expression + constant; -} - - -inline -Expression operator+( double constant, const Term& term ) -{ - return term + constant; -} - - -inline -Expression operator+( double constant, const Variable& variable ) -{ - return variable + constant; -} - - -inline -Expression operator-( double constant, const Expression& expression ) -{ - return -expression + constant; -} - - -inline -Expression operator-( double constant, const Term& term ) -{ - return -term + constant; -} - - -inline -Expression operator-( double constant, const Variable& variable ) -{ - return -variable + constant; -} - - -// Expression relations - -inline -Constraint operator==( const Expression& first, const Expression& second ) -{ - return Constraint( first - second, OP_EQ ); -} - - -inline -Constraint operator==( const Expression& expression, const Term& term ) -{ - return expression == Expression( term ); -} - - -inline -Constraint operator==( const Expression& expression, const Variable& variable ) -{ - return expression == Term( variable ); -} - - -inline -Constraint operator==( const Expression& expression, double constant ) -{ - return expression == Expression( constant ); -} - - -inline -Constraint operator<=( const Expression& first, const Expression& second ) -{ - return Constraint( first - second, OP_LE ); -} - - -inline -Constraint operator<=( const Expression& expression, const Term& term ) -{ - return expression <= Expression( term ); -} - - -inline -Constraint operator<=( const Expression& expression, const Variable& variable ) -{ - return expression <= Term( variable ); -} - - -inline -Constraint operator<=( const Expression& expression, double constant ) -{ - return expression <= Expression( constant ); -} - - -inline -Constraint operator>=( const Expression& first, const Expression& second ) -{ - return Constraint( first - second, OP_GE ); -} - - -inline -Constraint operator>=( const Expression& expression, const Term& term ) -{ - return expression >= Expression( term ); -} - - -inline -Constraint operator>=( const Expression& expression, const Variable& variable ) -{ - return expression >= Term( variable ); -} - - -inline -Constraint operator>=( const Expression& expression, double constant ) -{ - return expression >= Expression( constant ); -} - - -// Term relations - -inline -Constraint operator==( const Term& term, const Expression& expression ) -{ - return expression == term; -} - - -inline -Constraint operator==( const Term& first, const Term& second ) -{ - return Expression( first ) == second; -} - - -inline -Constraint operator==( const Term& term, const Variable& variable ) -{ - return Expression( term ) == variable; -} - - -inline -Constraint operator==( const Term& term, double constant ) -{ - return Expression( term ) == constant; -} - - -inline -Constraint operator<=( const Term& term, const Expression& expression ) -{ - return expression >= term; -} - - -inline -Constraint operator<=( const Term& first, const Term& second ) -{ - return Expression( first ) <= second; -} - - -inline -Constraint operator<=( const Term& term, const Variable& variable ) -{ - return Expression( term ) <= variable; -} - - -inline -Constraint operator<=( const Term& term, double constant ) -{ - return Expression( term ) <= constant; -} - - -inline -Constraint operator>=( const Term& term, const Expression& expression ) -{ - return expression <= term; -} - - -inline -Constraint operator>=( const Term& first, const Term& second ) -{ - return Expression( first ) >= second; -} - - -inline -Constraint operator>=( const Term& term, const Variable& variable ) -{ - return Expression( term ) >= variable; -} - - -inline -Constraint operator>=( const Term& term, double constant ) -{ - return Expression( term ) >= constant; -} - - -// Variable relations -inline -Constraint operator==( const Variable& variable, const Expression& expression ) -{ - return expression == variable; -} - - -inline -Constraint operator==( const Variable& variable, const Term& term ) -{ - return term == variable; -} - - -inline -Constraint operator==( const Variable& first, const Variable& second ) -{ - return Term( first ) == second; -} - - -inline -Constraint operator==( const Variable& variable, double constant ) -{ - return Term( variable ) == constant; -} - - -inline -Constraint operator<=( const Variable& variable, const Expression& expression ) -{ - return expression >= variable; -} - - -inline -Constraint operator<=( const Variable& variable, const Term& term ) -{ - return term >= variable; -} - - -inline -Constraint operator<=( const Variable& first, const Variable& second ) -{ - return Term( first ) <= second; -} - - -inline -Constraint operator<=( const Variable& variable, double constant ) -{ - return Term( variable ) <= constant; -} - - -inline -Constraint operator>=( const Variable& variable, const Expression& expression ) -{ - return expression <= variable; -} - - -inline -Constraint operator>=( const Variable& variable, const Term& term ) -{ - return term <= variable; -} - - -inline -Constraint operator>=( const Variable& first, const Variable& second ) -{ - return Term( first ) >= second; -} - - -inline -Constraint operator>=( const Variable& variable, double constant ) -{ - return Term( variable ) >= constant; -} - - -// Double relations - -inline -Constraint operator==( double constant, const Expression& expression ) -{ - return expression == constant; -} - - -inline -Constraint operator==( double constant, const Term& term ) -{ - return term == constant; -} - - -inline -Constraint operator==( double constant, const Variable& variable ) -{ - return variable == constant; -} - - -inline -Constraint operator<=( double constant, const Expression& expression ) -{ - return expression >= constant; -} - - -inline -Constraint operator<=( double constant, const Term& term ) -{ - return term >= constant; -} - - -inline -Constraint operator<=( double constant, const Variable& variable ) -{ - return variable >= constant; -} - - -inline -Constraint operator>=( double constant, const Expression& expression ) -{ - return expression <= constant; -} - - -inline -Constraint operator>=( double constant, const Term& term ) -{ - return term <= constant; -} - - -inline -Constraint operator>=( double constant, const Variable& variable ) -{ - return variable <= constant; -} - - -// Constraint strength modifier - -inline -Constraint operator|( const Constraint& constraint, double strength ) -{ - return Constraint( constraint, strength ); -} - - -inline -Constraint operator|( double strength, const Constraint& constraint ) -{ - return constraint | strength; -} - -} // namespace kiwi diff --git a/thirdparty/include/kiwi/term.h b/thirdparty/include/kiwi/term.h deleted file mode 100644 index aecfdf06d..000000000 --- a/thirdparty/include/kiwi/term.h +++ /dev/null @@ -1,51 +0,0 @@ -/*----------------------------------------------------------------------------- -| Copyright (c) 2013-2017, Nucleic Development Team. -| -| Distributed under the terms of the Modified BSD License. -| -| The full license is in the file LICENSE, distributed with this software. -|----------------------------------------------------------------------------*/ -#pragma once -#include -#include "variable.h" - - -namespace kiwi -{ - -class Term -{ - -public: - - Term( const Variable& variable, double coefficient = 1.0 ) : - m_variable( variable ), m_coefficient( coefficient ) {} - - // to facilitate efficient map -> vector copies - Term( const std::pair& pair ) : - m_variable( pair.first ), m_coefficient( pair.second ) {} - - ~Term() {} - - const Variable& variable() const - { - return m_variable; - } - - double coefficient() const - { - return m_coefficient; - } - - double value() const - { - return m_coefficient * m_variable.value(); - } - -private: - - Variable m_variable; - double m_coefficient; -}; - -} // namespace kiwi diff --git a/thirdparty/include/kiwi/util.h b/thirdparty/include/kiwi/util.h deleted file mode 100644 index 560a43a74..000000000 --- a/thirdparty/include/kiwi/util.h +++ /dev/null @@ -1,24 +0,0 @@ -/*----------------------------------------------------------------------------- -| Copyright (c) 2013-2017, Nucleic Development Team. -| -| Distributed under the terms of the Modified BSD License. -| -| The full license is in the file LICENSE, distributed with this software. -|----------------------------------------------------------------------------*/ -#pragma once - -namespace kiwi -{ - -namespace impl -{ - -inline bool nearZero(double value) -{ - const double eps = 1.0e-8; - return value < 0.0 ? -value < eps : value < eps; -} - -} // namespace impl - -} // namespace kiwi diff --git a/thirdparty/include/kiwi/variable.h b/thirdparty/include/kiwi/variable.h deleted file mode 100644 index a4db77706..000000000 --- a/thirdparty/include/kiwi/variable.h +++ /dev/null @@ -1,111 +0,0 @@ -/*----------------------------------------------------------------------------- -| Copyright (c) 2013-2017, Nucleic Development Team. -| -| Distributed under the terms of the Modified BSD License. -| -| The full license is in the file LICENSE, distributed with this software. -|----------------------------------------------------------------------------*/ -#pragma once -#include -#include -#include "shareddata.h" - -namespace kiwi -{ - -class Variable -{ - -public: - class Context - { - public: - Context() {} - virtual ~Context() {} // LCOV_EXCL_LINE - }; - - Variable(Context *context = 0) : m_data(new VariableData("", context)) {} - - Variable(const std::string &name, Context *context = 0) : m_data(new VariableData(name, context)) {} - - Variable(const char *name, Context *context = 0) : m_data(new VariableData(name, context)) {} - - ~Variable() {} - - const std::string &name() const - { - return m_data->m_name; - } - - void setName(const char *name) - { - m_data->m_name = name; - } - - void setName(const std::string &name) - { - m_data->m_name = name; - } - - Context *context() const - { - return m_data->m_context.get(); - } - - void setContext(Context *context) - { - m_data->m_context.reset(context); - } - - double value() const - { - return m_data->m_value; - } - - void setValue(double value) - { - m_data->m_value = value; - } - - // operator== is used for symbolics - bool equals(const Variable &other) - { - return m_data == other.m_data; - } - -private: - class VariableData : public SharedData - { - - public: - VariableData(const std::string &name, Context *context) : SharedData(), - m_name(name), - m_context(context), - m_value(0.0) {} - - VariableData(const char *name, Context *context) : SharedData(), - m_name(name), - m_context(context), - m_value(0.0) {} - - ~VariableData() {} - - std::string m_name; - std::unique_ptr m_context; - double m_value; - - private: - VariableData(const VariableData &other); - - VariableData &operator=(const VariableData &other); - }; - - SharedDataPtr m_data; - - friend bool operator<(const Variable &lhs, const Variable &rhs) - { - return lhs.m_data < rhs.m_data; - } -}; - -} // namespace kiwi diff --git a/thirdparty/include/kiwi/version.h b/thirdparty/include/kiwi/version.h deleted file mode 100644 index f6154482a..000000000 --- a/thirdparty/include/kiwi/version.h +++ /dev/null @@ -1,14 +0,0 @@ -/*----------------------------------------------------------------------------- -| Copyright (c) 2013-2020, Nucleic Development Team. -| -| Distributed under the terms of the Modified BSD License. -| -| The full license is in the file LICENSE, distributed with this software. -|----------------------------------------------------------------------------*/ -#pragma once - -#define KIWI_MAJOR_VERSION 1 -#define KIWI_MINOR_VERSION 2 -#define KIWI_MICRO_VERSION 0 -#define KIWI_VERSION_HEX 0x010200 -#define KIWI_VERSION "1.2.0"