/usr/share/doc/libmuparser-doc/html/sources/mup_usage.html is in libmuparser-doc 2.2.3-3.
This file is owned by root:root, with mode 0o644.
The actual contents of the file can be viewed below.
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 162 163 164 165 166 167 168 169 170 171 172 173 174 175 176 177 178 179 180 181 182 183 184 185 186 187 188 189 190 191 192 | <!--
//
//
//
// Adding the parser to your projects
//
//
//
-->
<br/>
<h1><a id="idBuild"></a>Build instructions</h1>
<h2><a id="idInstWin"></a>Building on win32</h2>
<b>muParser</b> supports various win32 command-line compilers:
<ul>
<li>Mingw</li>
<li>Borland C++</li>
<li>Watcom</li>
<li>Microsoft CL</li>
</ul>
In order to compile muParser from makefiles, open a command prompt then move to the muParser/build directory and
type:
<ul>
<li>mingw32-make -fmakefile.mingw for mingw</li>
<li>nmake -fmakefile.vc for msvc</li>
<li>make -fmakefile.bcc for borland</li>
<li>wmake -fmakefile.wat for watcom</li>
</ul>
All makefiles support the following options:
<pre>
# Set to 1 to build debug version [0,1]
# 0 - Release
# 1 - Debug
DEBUG = 0
# Set to 1 to build shared (DLL) version [0,1]
# 0 - Static
# 1 - DLL
SHARED = 0
# Set to 1 to compile samples [0,1]
SAMPLES = 1
</pre>
The muParser library is created in the 'lib' folder and the sample
binaries are created in samples\example1 or samples\example2. (You may need to copy the dll
into the example2 directory in order to run it.)
<table>
<tr>
<td><img src="images/warning.gif" alt="warning"/></td>
<td>samples\example1 can be compiled *only* when building muParser as a STATIC library (SHARED=0).<br/>
samples\example2 can be compiled *only* when building muParser as a SHARED library (SHARED=1).
</td>
</tr>
</table>
<h2><a id="idInstLinux"></a>Building on BSD/Linux</h2>
muParser can be installed just extracting the sources somewhere and then, from a terminal, typing:
<pre>
cd [path to muParser]
./configure [--enable-shared=yes/no] [--enable-samples=yes/no]
[--enable-debug=yes/no]
make
[sudo*] make install
</pre>
<small>* = this command must be executed with root permissions and thus
you have to use 'sudo' or just 'su' to gain root access.
Note that installation is not strictly required.</small>
<p>
The "make" step will create the muParser library in 'lib' and the
sample binary in samples/example1. The samples/example2 is win32-specific and
thus won't be built.
</p>
<h2><a id="idInstMisc"></a>Other miscellaneous info Unix-specific</h2>
If you don't like to have your muParser folder filled by temporary
files created by GCC, then you can do the following:
<pre>
mkdir mybuild && cd mybuild && ../configure && make
</pre>
to put all object files in the "mybuild" directory. If you want to use
muParser library in your programs, you can use the pkg-config program
(this works only if muParser was installed with 'make install' !).
The commands:
<ul>
<li>pkg-config muparser --cflags</li>
<li>pkg-config muparser --libs</li>
</ul>
will return all useful info you need to build your programs against
muParser !
<h2><a id="idInstInc"></a><a name="idUseSource"></a>Including the source code directly</h2>
Sometimes including the library sources directly into an application is the easiest
possibility to avoid linker conflicts originating from different versions of the
runtime libraries used by the parser and your project.
In order to use the parser simply include the following files into your project:
<p>
<i>muParser.cpp</i><br/>
<i>muParserBase.cpp</i><br/>
<i>muParserBytecode.cpp</i><br/>
<i>muParserCallback.cpp</i><br/>
<i>muParserError.cpp</i><br/>
<i>muParserTokenReader.cpp</i>
</p>
And make sure the following files can be found in your projects include path:
<p>
<i>muParser.h</i><br/>
<i>muParserBase.h</i><br/>
<i>muParserBytecode.h</i><br/>
<i>muParserCallback.h</i><br/>
<i>muParserDef.h</i><br/>
<i>muParserError.h</i><br/>
<i>muParserFixes.h</i><br/>
<i>muParserStack.h</i><br/>
<i>muParserToken.h</i><br/>
<i>muParserTokenReader.h</i><br/>
</p>
The parser class and all related classes reside in the namespace <code>mu</code> (MathUtils). So make sure to either
add a using
<pre>
using namespace mu;
</pre>
to your files or reference all classes with their complete name.
<h2><a id="idCompilerSwitches"></a>Compiler switches</h2>
If you use muParser by compiling your own version or including the source code directly you can use
a set of preprocessor definitions in order to customize its behaviour. The following definitions
are located in the file <b>muParserDef.h</b>:
<pre>
<span class="code_pp">#define MUP_BASETYPE double</span>
</pre>
The macro <b>MUP_BASETYPE</b> defines the underlying datatype used by muParser. This can be any
floating point value type (<code>float</code>,<code>double</code> or <code>long double</code>).
The macro defaults to <code>double</code>. Modify this value if you need higher precision or want
to use muParser seemless with client code that is using float as its data type.
<pre>
<span class="code_pp">#define MUP_MATH_EXCEPTIONS</span>
</pre>
When this option is set an exception is generated in case of a division by zero. By default this
option is not set and division by zero is silently signalled with +/-inf.
<a id="idCompilerSwitches_openMP"></a>
<pre>
<span class="code_pp">#define MUP_USE_OPENMP</span>
</pre>
If this option is set OpenMP is used for parallelization of the calculations performed in the bulk
mode. By default this option is not set. According to my observations OpenMP does not bring any
benefit when used with fully optimized code as produced by C++/VS2008 under Windows. It does however
bring a significant performance increase when using the muParser dll from C#. I don't really have a good
explanation for this but my best guess is that C# has a significant overhead when muParser is using
callback functions implemented as C# delegates. OpenMP can spread this overhead amongst multiple
cores whilst it can't improve the C++ code since it is already highly optimized and the execution
speed is finally limited by the memory bandwidth.
<pre>
<span class="code_pp">#define MUP_STRING_TYPE std::wstring</span>
</pre>
This definition determines the string type used by muParser. This can either be
<code>std::string</code> or <code>std::wstring</code>. This definition shouldn't be set directly.
It is defined to <code>std::wstring</code> if there is a preprocessor macro <code>_UNICODE</code>
present. (This definition is set by VS2008 accoring to the project settings.)
<h2><a id="idHelp"></a>Where to ask for help</h2>
If you find problems with either compilation, installation or usage
of muParser, then you can ask in the muParser forum at:<br/>
<ul>
<li><a href="https://sourceforge.net/forum/forum.php?forum_id=462843">https://sourceforge.net/forum/forum.php?forum_id=462843</a></li>
</ul>
For more info about muParser, visit:
<ul>
<li><a href="http://sourceforge.net/projects/muparser/">http://sourceforge.net/projects/muparser/</a><br/></li>
<li><a href="http://muparser.sourceforge.net">http://muparser.sourceforge.net</a></li>
</ul>
|