open pdf form itextsharp c# : Remove text from pdf SDK software API wpf windows asp.net sharepoint R-admin3-part1660

Chapter 6: Add-on packages
26
CXXFLAGS=-g -O -mtune=native
## for Fortran code
FFLAGS=-g -O -mtune=native
## for Fortran 9x code
FCFLAGS=-g -O -mtune=native
Another use is to override the settings in a binary installation of R. For example, to use a
different Fortran compiler on OS X
F77 = /usr/local/gfortran/bin/gfortran
FC = /usr/local/gfortran/bin/gfortran
FLIBS = -L/usr/local/gfortran/lib/gcc/x86_64-apple-darwin14/5.2.0
-L/usr/local/gfortran/lib -lgfortran -lquadmath -lm
(line split for legibility here).
There is also provision for a site-wide Makevars.site file under R_HOME/etc (in a sub-
architecture-specific directory if appropriate). This is read immediately after Makeconf, and an
alternative file can be specified by environment variable R_MAKEVARS_SITE.
Note that these mechanisms do not work with packages which fail to pass settings down
to sub-makes, perhaps reading etc/Makeconf in makefiles in subdirectories. Fortunately such
packages are unusual.
6.3.4 Multiple sub-architectures
When installing packages from their sources, there are some extra considerations on installations
which use sub-architectures. These are commonly used on Windows but can in principle be used
on other platforms.
When a source package is installed by a build of R which supports multiple sub-architectures,
the normal installation process installs the packages for all sub-architectures. The exceptions
are
Unix-alikes
where there is an configure script, or a file src/Makefile.
Windows
where there is a non-empty configure.win script,or a file src/Makefile.win (with
some exceptions where the package is known to have an architecture-independent
configure.win, or if --force-biarch or field ‘Biarch’ in the DESCRIPTION file is
used to assert so).
In those cases only the current architecture is installed. Further sub-architectures can be in-
stalled by
R CMD INSTALL --libs-only pkg
using the path to R or R --arch to select the additional sub-architecture. There is also R CMD
INSTALL --merge-multiarch to build and merge the two architectures, starting with a source
tarball.
6.3.5 Byte-compilation
The base and recommended packages are byte-compiled by default. Other packages can be
byte-compiled on installation by using R CMD INSTALL with option --byte-compile or by
install.packages(type = "source", INSTALL_opts = "--byte-compile").
Not all contributed packages work correctly when byte-compiled. For most packages (espe-
cially those which make extensive use of compiled code) the speed-up is small. Unless a package
is used frequently the time spent in byte-compilation can outweigh the time saved in execution:
also byte-compilation can add substantially to the installed size of the package.
Remove text from pdf - delete, remove text from PDF file in C#.net, ASP.NET, MVC, Ajax, WinForms, WPF
Allow C# developers to use mature APIs to delete and remove text content from PDF document
how to delete text from a pdf; how to copy text out of a pdf
Remove text from pdf - VB.NET PDF delete text library: delete, remove text from PDF file in vb.net, ASP.NET, MVC, Ajax, WinForms, WPF
VB.NET Programming Guide to Delete Text from PDF File
how to delete text in pdf converter; how to edit and delete text in pdf file
Chapter 6: Add-on packages
27
Byte-compilation can be controlled on a per-package basis by the ‘ByteCompile’ field in the
DESCRIPTION file.
6.3.6 External software
Some R packages contain compiled code which links to external software libraries. Unless the
external library is statically linked (which is done as much as possible for binary packages on
Windows and OS X), the libraries have to be found when the package is loaded and not just
when it is installed. How this should be done depends on the OS (and in some cases the version).
For Unix-alikes except OS X the primary mechanism is the ld.so cache controlled by
ldconfig: external dynamic libraries recorded in that cache will be found. Standard library
locations will be covered by the cache, and well-designed software will add its locations (as
for example openmpi does on Fedora). The secondary mechanism is to consult the environ-
ment variable LD_LIBRARY_PATH. Now the R script controls that variable, and sets it to the
concatenation of R_LD_LIBRARY_PATH, R_JAVA_LD_LIBRARY_PATH and the environment value of
LD_LIBRARY_PATH. The first two have defaults which are normally set when R is installed (but
can be overridden in the environment) so LD_LIBRARY_PATH is the best choice for a user to set.
On OS X the primary mechanism is to embed the absolute path to dependent dynamic
libraries into an object when it is compiled. Few R packages arrange to do so, but it can be
edited
6
via install_name_tool — that only deals with direct dependencies and those would
also need to be compiled to include the absolute paths of their dependencies. If the choice of
absolute path is to be deferred to load time, how they are resolved is described in man dyld:
the role of LD_LIBRARY_PATH is replaced on OS X by DYLD_LIBRARY_PATH and latterly DYLD_
FALLBACK_LIBRARY_PATH. Running R CMD otool -L on the package shared object will show
where (if anywhere) its dependencies are resolved. DYLD_FALLBACK_LIBRARY_PATH is preferred
(and it is that which is manipulated by the R script), but as from 10.11 (‘El Capitan’) the
default behaviour had been changed for security reasons to discard these environment variables
when invoking a shell script (and R is a shell script). That makes the only portable option to
set R_LD_LIBRARY_PATH in the environment, something like
export R_LD_LIBRARY_PATH="‘R RHOME‘/lib:/opt/local/lib"
The precise rules for where Windows looks for DLLs are complex and depend on the version
of Windows. But for present purposes the main solution is to put the directories containing
the DLLs the package links to (and any those DLLs link to) on the PATH. 64-bit versions of
Windows will ignore 32-bit DLLs from 64-bit R and vice versa.
The danger with any of the methods which involve setting environment variables is of in-
advertently masking a system library. This is less for DYLD_FALLBACK_LIBRARY_PATH and for
appending to PATH on Windows (as it should already contain the system library paths).
6.4 Updating packages
The command update.packages() is the simplest way to ensure that all the packages on your
system are up to date. It downloads the list of available packages and their current versions,
compares it with those installed and offers to fetch and install any that have later versions on
the repositories.
An alternative interface to keeping packages up-to-date is provided by the command
packageStatus(), which returns an object with information on all installed packages and pack-
ages available at multiple repositories. The print and summary methods give an overview of
installed and available packages, the upgrade method offers to fetch and install the latest ver-
sions of outdated packages.
6
They need tohave been created using -headerpad_max_install_names, which is the default for an R package.
C# PDF remove image library: remove, delete images from PDF in C#.
Delete Text from PDF. Text: Replace Text in PDF. Image: Insert Image to PDF. Image: Remove Image from PDF Page. Image: Copy, Paste, Cut
how to erase text in pdf online; how to delete text in pdf document
VB.NET PDF remove image library: remove, delete images from PDF in
PDF Write. Text: Insert Text to PDF. Text: Delete Text from PDF. Text: Replace Text in PDF. Image: Insert Image to PDF. Image: Remove Image from PDF Page. Image
remove text from pdf; remove text watermark from pdf
Chapter 6: Add-on packages
28
One sometimes-useful additional piece of information that packageStatus() returns is the
status of a package, as "ok", "upgrade" or "unavailable" (in the currently selected reposito-
ries). For example
> inst <- packageStatus()$inst
> inst[inst$Status != "ok", c("Package", "Version", "Status")]
Package Version
Status
Biobase
Biobase
2.8.0 unavailable
RCurl
RCurl
1.4-2
upgrade
Rgraphviz
Rgraphviz 1.26.0 unavailable
rgdal
rgdal 0.6-27
upgrade
6.5 Removing packages
Packages can be removed in a number of ways. From a command prompt they can be removed
by
R CMD REMOVE -l /path/to/library pkg1 pkg2 ...
From a running R process they can be removed by
> remove.packages(c("pkg1", "pkg2"),
lib = file.path("path", "to", "library"))
Finally, one can just remove the package directory from the library.
6.6 Setting up a package repository
Utilities such as install.packages can be pointed at any
CRAN
-style repository, and R users
may want to set up their own. The ‘base’ of a repository is a URL such as http://www.stats.
ox.ac.uk/pub/RWin: this must be an URL scheme that download.packages supports (which
also includes ‘ftp://’ and ‘file://’ and (from R 3.3.0 and perhaps earlier) ‘https://’). Under
that base URL there should be directory trees for one or more of the following types of package
distributions:
 "source": located at src/contrib and containing .tar.gz files. Other forms of compres-
sion can be used, e.g. .tar.bz2 or .tar.xz files. Complete repositories contain the sources
corresponding to any binary packages, and in any case it is wise to have a src/contrib
area with a possibly empty PACKAGES file.
 "win.binary": located at bin/windows/contrib/x.y for R versions x.y.z and containing
.zip files for Windows.
 "mac.binary.mavericks": located at bin/macosx/mavericks/contrib/3.y for the
CRAN build for ‘Mavericks’ (and later) for R versions 3.y.z, containing .tgz files.
Each terminal directory must also containa PACKAGES file. This can be a concatenation of the
DESCRIPTION files of thepackages separated by blank lines, but only a few of the fields are needed.
The simplest way to set up such a file is to use function write_PACKAGES in the tools package,
and its help explains which fields are needed. Optionally there can also be a PACKAGES.gz file,
agzip-compressed version of PACKAGES—as this will be downloaded in preference to PACKAGES
it should be included for large repositories. (If you have a mis-configured server that does not
report correctly non-existent files you may need PACKAGES.gz.)
To add your repository to the list offered by setRepositories(), see the help file for that
function.
Incomplete repositories are better specified via a contriburl argument than via being set
as a repository.
VB.NET PDF Page Delete Library: remove PDF pages in vb.net, ASP.
Able to remove a single page from adobe PDF document in VB.NET. Ability to remove consecutive pages from PDF file in VB.NET. Enable
how to delete text in pdf file; how to delete text from pdf
VB.NET PDF Password Library: add, remove, edit PDF file password
Remove password from PDF. Dim outputFilePath As String = Program.RootPath + "\\" Remove.pdf" ' Remove password in the input file and output to a new file.
delete text from pdf with acrobat; delete text from pdf online
Chapter 6: Add-on packages
29
Arepository can contain subdirectories, when the descriptions in the PACKAGES file of pack-
ages in subdirectories must include a line of the form
Path: path/to/subdirectory
—once again write_PACKAGES is the simplest way to set this up.
6.7 Checking installed source packages
It can be convenient to run R CMD check on an installed package, particularly on a platform
which uses sub-architectures. The outline of how to do this is, with the source package in
directory pkg (or a tarball filename):
R CMD INSTALL -l libdir pkg > pkg.log 2>&1
R CMD check -l libdir --install=check:pkg.log pkg
Where sub-architectures are in use the R CMD check line can be repeated with additional archi-
tectures by
R --arch arch CMD check -l libdir --extra-arch --install=check:pkg.log pkg
where --extra-arch selects only those checks which depend on the installed code and not those
which analyse the sources. (If multiple sub-architectures fail only because they need different
settings, e.g. environment variables, --no-multiarch may need to be added to the INSTALL
lines.) On Unix-alikes the architecture to run is selected by --arch: this can also be used on
Windows with R_HOME/bin/R.exe, but it is more usual to select the path to the Rcmd.exe of
the desired architecture.
So on Windows to install, check and package for distribution a source package from a tarball
which has been tested on another platform one might use
.../bin/i386/Rcmd INSTALL -l libdir tarball --build > pkg.log 2>&1
.../bin/i386/Rcmd check -l libdir --extra-arch --install=check:pkg.log pkg
.../bin/x64/Rcmd check -l libdir --extra-arch --install=check:pkg.log pkg
where one might want to run the second and third lines in a different shell with different settings
for environment variables and the path (to find external software, notably for Gtk+).
RCMD INSTALL can do a i386 install and then add the x64 DLL from a single command by
R CMD INSTALL --merge-multiarch -l libdir tarball
and --build can be added to zip up the installation.
C# PDF Page Delete Library: remove PDF pages in C#.net, ASP.NET
console application. Able to remove a single page from PDF document. Ability to remove a range of pages from PDF file. Free trial package
pdf text watermark remover; delete text pdf file
C# PDF Password Library: add, remove, edit PDF file password in C#
String outputFilePath = Program.RootPath + "\\" Remove.pdf"; // Remove password in the input file and output to a new file. int
acrobat delete text in pdf; how to delete text in a pdf file
30
7 Internationalization and Localization
Internationalization refers to the process of enabling support for many human languages, and
localization to adapting to a specific country and language.
Current builds of R support all the character sets that the underlying OS can handle. These
are interpreted according to the current locale, a sufficiently complicated topic to merit a
separate section. Note though that R has no built-in support for right-to-left languages and
bidirectional output, relying on the OS services. For example, how character vectors in UTF-8
containing both English digits and Hebrew characters are printed is OS-dependent (and perhaps
locale-dependent).
The other aspect of the internationalization is support for the translation of messages. This
is enabled in almost all builds of R.
7.1 Locales
Alocale is a description of the local environment of the user, including the preferred language,
the encoding of characters, the currency used and its conventions, and so on. Aspects of the
locale are accessed by the R functions Sys.getlocale and Sys.localeconv.
The system of naming locales is OS-specific. There is quite wide agreement on schemes, but
not on the details of their implementation. A locale needs to specify
 A human language. These are generally specified by a lower-case two-character abbreviation
following ISO 639 (see e.g. https://en.wikipedia.org/wiki/ISO_639-1).
 A ‘territory’, used mainly tospecify the currency. These are generally specified by anupper-
case two-character abbreviation following ISO 3166 (see e.g. https://en.wikipedia.org/
wiki/ISO_3166).
 A charset encoding,which determines both how abyte stream shouldbe dividedinto charac-
ters, and which characters the subsequences of bytes represent. Sometimes the combination
of language and territory is usedto specify the encoding, for example to distinguish between
traditional and simplified Chinese.
 Optionally, a modifier, for example to indicate that Austria is to be considered pre- or
post-Euro. The modifier is also used to indicate the script (@latin, @cyrillic for Serbian,
@iqtelif) or language dialect (e.g. @saaho, a dialect of Afar, and @bokmal and @nynorsk,
dialects of Norwegian regarded by some OSes as separate languages, no and nn).
Ris principally concerned with the first (for translations) and third. Note that the charset
may be deducible from the language, as some OSes offer only one charset per language.
7.1.1 Locales under Unix-alikes
Modern Linux uses the XPG
1
locale specifications which have the form ‘en_GB’, ‘en_GB.UTF-8’,
‘aa_ER.UTF-8@saaho’, ‘de_AT.iso885915@euro’, the components being in the order listed
above. (See man locale and locale -a for more details.) Similar schemes are used by most
Unix-alikes: some (including some distributions of Linux) use ‘.utf8’ rather than ‘.UTF-8’.
Note that whereas UTF-8 locales are nowadays almost universally used, locales such as
‘en_GB’ use 8-bit encodings for backwards compatibility.
7.1.2 Locales under Windows
Windows also uses locales, but specified in a rather less concise way. Most users will encounter
locales only via drop-down menus, but more information and lists can be found at https://
1
‘X/Open Portability Guide’, which has had several versions.
C# PDF Digital Signature Library: add, remove, update PDF digital
Delete Text from PDF. Text: Replace Text in PDF. Image: Insert Image to PDF. Image: Remove Image from PDF Page. Image: Copy, Paste, Cut
erase pdf text; how to delete text in pdf document
C# PDF bookmark Library: add, remove, update PDF bookmarks in C#.
Ability to remove and delete bookmark and outline entry.GetLocation()); Console.WriteLine("Text: " + entry.GetText NET Sample Code: Update PDF Document Outline
delete text pdf acrobat; how to delete text in pdf using acrobat professional
Chapter 7: Internationalization and Localization
31
msdn.microsoft.com/en-us/library/hzz3tw78(v=vs.80) (or if Microsoft moves it yet again,
search for ‘Windows language country strings’).
It offers only one encoding per language.
Some care is needed with Windows’ locale names. For example, chinese is Traditional
Chinese and not Simplified Chinese as used in most of the Chinese-speaking world.
7.1.3 Locales under OS X
OS X supports locales in its own particular way, but the R GUI tries to make this easier for users.
Seehttps://developer.apple.com/documentation/MacOSX/Conceptual/BPInternational/
for how users can set their locales. As with Windows, end users will generally only see lists
of languages/territories. Users of R in a terminal may need to set the locale to something like
‘en_GB.UTF-8’ if it defaults to ‘C’ (as it sometimes does when logging in remotely and for batch
jobs: note whether Terminal sets the LANG environment variable is an (advanced) preference,
but does so by default).
Internally OS X uses a form similar to Linux: the main difference from other Unix-alikes is
that where a character set is not specified it is assumed to be UTF-8.
7.2 Localization of messages
The preferred language for messages is by default taken from the locale. This can be overridden
first by the setting of the environment variable LANGUAGE and then
2
by the environment variables
LC_ALL, LC_MESSAGES and LANG. (The last three are normally used toset the locale and so should
not be needed, but the first is only used to select the language for messages.) The code tries
hard to map locales to languages, but on some systems (notably Windows) the locale names
needed for the environment variable LC_ALL do not all correspond to XPG language names and
so LANGUAGE may need to be set. (One example is ‘LC_ALL=es’ on Windows which sets the locale
to Estonian and the language to Spanish.)
It is usually possible to change the language once R is running via (not Windows)
Sys.setlocale("LC_MESSAGES", "new_locale"), or by setting an environment variable such
as LANGUAGE, provided
3
the language you are changing to can be output in the current character
set. But this is OS-specific, and has been known to stop working on an OS upgrade.
Messages are divided into domains, and translations may be available for some or all messages
in a domain. R makes use of the following domains.
 Domain R for the C-level error and warning messages from the R interpreter.
 Domain R-pkg for the R stop, warning and message messages in each package, including
R-base for the base package.
 Domain pkg for the C-level messages in each package.
 Domain RGui for the menus etc of the R for Windows GUI front-end.
Dividing up the messages in this way allows R to be extensible: as packages are loaded, their
message translation catalogues can be loaded too.
Rcan be built without support for translations, but it is enabled by default.
R-level and C-level domains are subtly different, for example in the way strings are canoni-
calized before being passed for translation.
Translations are lookedfor by domain according to the currently specifiedlanguage, as specif-
ically as possible, so for example an Austrian (‘de_AT’) translation catalogue will be used in pref-
erence to a generic German one (‘de’) for an Austrian user. However, if a specific translation
2
On some systems setting LC_ALL or LC_MESSAGES to ‘C’ disables LANGUAGE.
3
If you try changing from French toRussian except in a UTF-8locale,you will most likely find messages change
to English.
Chapter 7: Internationalization and Localization
32
catalogue exists but does not contain a translation, the less specific catalogues are consulted.
For example, R has catalogues for ‘en_GB’ that translate the Americanisms (e.g., ‘gray’) in the
standard messages into English.
4
Two other examples: there are catalogues for ‘es’, which is
Spanish as written in Spain and these will by default also be used in Spanish-speaking Latin
American countries, and also for ‘pt_BR’, which are used for Brazilian locales but not for locales
specifying Portugal.
Translations in the right language but the wrong charset are made use of by on-the-fly re-
encoding. The LANGUAGE variable (only) can be a colon-separated list, for example ‘se:de’,
giving a set of languages in decreasing order of preference. One special value is ‘en@quot’, which
can be used in a UTF-8 locale to have American error messages with pairs of single quotes
translated to Unicode directional quotes.
If no suitable translation catalogue is found or a particular message is not translated in any
suitable catalogue, ‘English’
5
is used.
See https://developer.r-project.org/Translations30.html for how to prepare and
install translation catalogues.
4
the language written in England: some people living in the USA appropriate this name for their language.
5
with Americanisms.
33
8 Choosing between 32- and 64-bit builds
Almost all current
CPU
shave both 32- and 64-bit sets of instructions. Most OSes running on
such
CPU
soffer the choice of building a 32-bit or a 64-bit version of R (and details are given
below under specific OSes). For most a 32-bit version is the default, but for some (e.g., ‘x86_64’
Linux and OS X >= 10.6) 64-bit is.
All current versions of R use 32-bit integers and
ISO
/
IEC
60559
1
double-precision reals, and
so compute to the same precision
2
and with the same limits on the sizes of numerical quantities.
The principal difference is in the size of the pointers.
64-bit builds have both advantages and disadvantages:
 The total virtual memory space made available to a 32-bit process is limited by the pointer
size to 4GB, and on most OSes to 3GB (or even 2GB). The limits for 64-bit processes are
much larger (e.g. 8–128TB).
Rallocates memory for large objects as needed, and removes any unused ones at garbage
collection. When the sizes of objects become an appreciable fraction of the address limit,
fragmentation of the address space becomes an issue and there may be no hole available
that is the size requested. This can cause more frequent garbage collection or the inability
to allocate large objects. As a guide, this will become an issue for 32-bit builds with objects
more than 10% of the size of the address space (around 300Mb) or when the total size of
objects in use is around one third (around 1Gb).
 Only 64-bit builds support ‘long vectors’, those with 2
31
or more elements (which needs at
least 16GB of storage for each numeric vector).
 Most 32-bit OSes by default limit file sizes to 2GB (and this may also apply to 32-bit builds
on 64-bit OSes). This can often be worked around: and configure selects suitable defines
if this is possible. (We have also largely worked around that limit on 32-bit Windows.)
64-bit builds have much larger limits.
 Because the pointers are larger, R’s basic structures are larger. This means that R objects
take more space and (usually) more time to manipulate. So 64-bit builds of R will, all
other things being equal, run slower than 32-bit builds. (On Sparc Solaris the difference
was 15-20%.)
 However, ‘other things’ may not be equal. In the specific case of ‘x86_64’ vs ‘ix86’, the
64-bit CPU has features (such as SSE2 instructions) which are guaranteed to be present but
are optional on the 32-bit CPU, and also has more general-purpose registers. This means
that on chips like a desktop Intel i7 the vanilla 64-bit version of R has been around 10%
faster on bothLinux and OS X. (Laptop CPUs are usually relatively slower in 64-bit mode.)
So, for speed you may want to use a 32-bit build (especially on a laptop), but to handle large
datasets (and perhaps large files) a 64-bit build. You can often build both and install them
in the same place: See Section 2.6 [Sub-architectures], page 8. (This is done for the Windows
binary distributions.)
Even on 64-bit builds of R there are limits on the size of R objects (see
help("Memory-limits"), some of which stem from the use of 32-bit integers (espe-
cially in FORTRAN code).
For example, the dimensions of an array are limited to
2
31
1.
1
also known as
IEEE
754
2
at least when storing quantities: the on-FPU precision is allowed to vary
34
9 The standalone Rmath library
Theroutines supportingthe distribution andspecial
1
functions inR and afew others are declared
in C header file Rmath.h. These can be compiled into a standalone library for linking to other
applications. (Note that they are not a separate library when R is built, and the standalone
version differs in several ways.)
The makefiles and other sources needed are in directory src/nmath/standalone, so the
following instructions assume that is the current working directory (in the build directory tree
on a Unix-alike if that is separate from the sources).
Rmath.h contains ‘R_VERSION_STRING’, which is a character string containing the current R
version, for example "3.3.0".
There is full access to R’s handling of NaN, Inf and -Inf via special versions of the macros
and functions
ISNAN, R_FINITE, R_log, R_pow and R_pow_di
and (extern) constants R_PosInf, R_NegInf and NA_REAL.
There is no support for R’s notion of missing values, in particular not for NA_INTEGER nor
the distinction between NA and NaN for doubles.
Alittle care is needed to use the random-number routines. You will need to supply the
uniform random number generator
double unif_rand(void)
or use the one supplied (and with a shared library or DLL you may have to use the one supplied,
which is the Marsaglia-multicarry with an entry point
set_seed(unsigned int, unsigned int)
to set its seeds).
The facilities to change the normal random number generator are available through the
constant N01
kind. This takes values from the enumeration type
typedef enum {
BUGGY_KINDERMAN_RAMAGE,
AHRENS_DIETER,
BOX_MULLER,
USER_NORM,
INVERSION,
KINDERMAN_RAMAGE
} N01type;
(and ‘USER_NORM’ is not available).
9.1 Unix-alikes
If R has not already been made in the directory tree, configure must be run as described in
the main build instructions.
Then (in src/nmath/standalone)
make
will make standalone libraries libRmath.a and libRmath.so (libRmath.dylib on OS X): ‘make
static’ and ‘make shared’ will create just one of them.
To use the routines in your own C or C++ programs, include
#define MATHLIB_STANDALONE
1
e.g. Bessel, beta and gamma functions
Chapter 9: The standalone Rmath library
35
#include <Rmath.h>
and link against ‘-lRmath’ (and ‘-lm’ if needed on your OS). The example file test.c does
nothing useful, but is provided to test the process (via make test). Note that you will probably
not be able to run it unless you add the directory containing libRmath.so to the LD_LIBRARY_
PATH environment variable (libRmath.dylib, DYLD_FALLBACK_LIBRARY_PATH on OS X).
The targets
make install
make uninstall
will (un)install the header Rmath.h and shared and static libraries (if built). Both prefix= and
DESTDIR are supported, together with more precise control as described for the main build.
‘make install’ installs a file for pkg-config to use by e.g.
$(CC) ‘pkg-config --cflags libRmath‘ -c test.c
$(CC) ‘pkg-config --libs libRmath‘ test.o -o test
On some systems ‘make install-strip’ will install a stripped shared library.
9.2 Windows
You need to set up
2
almost all the tools to make R and then run (in a Unix-like shell)
(cd ../../gnuwin32; make MkRules)
(cd ../../include; make -f Makefile.win config.h Rconfig.h Rmath.h)
make -f Makefile.win
Alternatively, in a cmd.exe shell use
cd ../../include
make -f Makefile.win config.h Rconfig.h Rmath.h
cd ../nmath/standalone
make -f Makefile.win
This creates a static library libRmath.a and a DLL Rmath.dll. If you want an import
library libRmath.dll.a (you don’t need one), use
make -f Makefile.win shared implib
To use the routines in your own C or C++ programs using MinGW-w64, include
#define MATHLIB_STANDALONE
#include <Rmath.h>
and link against ‘-lRmath’. This will use the first found of libRmath.dll.a, libRmath.a and
Rmath.dll in that order, so the result depends on which files are present. You should be able
to force static or dynamic linking via
-Wl,-Bstatic -lRmath -Wl,Bdynamic
-Wl,-Bdynamic -lRmath
or by linking to explicit files (as in the ‘test’ target in Makefile.win: this makes two executa-
bles, test.exe which is dynamically linked, and test-static.exe, which is statically linked).
It is possible to link to Rmath.dll using other compilers, either directly or via an import
library: if you make a MinGW-w64 import library as above, you will create a file Rmath.def
which can be used (possibly after editing) to create an import library for other systems such as
Visual C++.
If you make use of dynamic linking you should use
#define MATHLIB_STANDALONE
#define RMATH_DLL
2
including copying MkRules.dist to MkRule.local and selecting the architecture.
Documents you may be interested
Documents you may be interested