MODS

In a development branch, the 'mods-dir' directory contains a file for
each git branch in the pqR repository, documenting what that branch is
for.  These files will ultimately be combined in a release branch to
produce the MODS file in the main source directory.

Development branches start with branch 00, which is identical to the
version of R released by the R Core Team on which pqR is based
(currently R-2.15.0), except for the 00 and README files in mods-dir.

Later development branches have the form DD-desc, where DD is a
two-digit number, and desc is a descriptive string.  All branches
starting with DD are merged into the branch with number DD+1, which
does not contain any modifications of its own, except perhaps for
updates to the version number/date in VERSION/NEWS.Rd, or to this
README file, but which forms the basis for the development branches
starting with DD+1.

Release branches have names of the form Release-YYYY-MM-DD (and are
also given tag pqR-YYYY-MM-DD).  They are based on some merged
development branch (ie, with a name of the form DD).  Note that it may
be a good idea to have the development branch include the effects on
the source directory of a run of "make update-po" in the "po"
subdirectory of a build directory (which updates source references for
translations).

After the new release branch is created, the following should be done:

 1) Remove the file ".gitignore" using "git rm".

 2) Update the release date, which is stored in the (now mis-named)
    file "SVN-REVISION".  This should match the date in "NEWS.Rd",
    which would have been set in a development (or merge) branch.
    (The date in the "SVN-REVISION" file of a development branch
    should have approximately the correct year, but have month and day
    set to "00".)

 3) Create the file "configure" by running create-configure.  Add it
    to the git repository with "git add".

 4) Run configure and make in some build directory, with "C" locale.

 5) Create the files "NEWS", "NEWS.pdf", "doc/html/NEWS.html", and 
    "doc/html/R-admin.html" from source files, by copying them from
    the build directory to the source directory (R-admin.html from 
    doc/manual).  Add them to the git repository.

 6) Concatenate all files in the "mods-dir" directory into the file 
    "MODS", as follows:

      (cd mods-dir; cat README; for i in [0-9]*; \
       do echo " "; echo " "; echo ${i}:; echo " "; cat $i; done) >MODS

    Add it to the git repository, then delete the "mods-dir" directory
    with "git rm -r".

 7) Commit the above changes to create the final version for a release.
    Give this commit the pqR-YYYY-MM-DD tag.

The development branches that go into a release may be changed after
the release, with the new versions forming the basis for a later
release, but without the commits that produce these new versions being
merged into the earlier release.  Once a release branch is created, it
is modified only in exceptional circumstances (such as discovery that
a file is missing).

The "master" branch is used only for adding versions of R released by
the R Core Team, starting with R-2.11.1, for each of which there is a
tag.
 
 
00:
 
The R release pqR is based on, unchanged except for adding the README
in mods, and the 00 file within it, containing this text.
 
 
00-admin:
 
Updates R-admin.texi to minimally say where pqR can be obtained.
 
 
00-copyright:
 
This mod updates the copyright notices at the start of many
source files.
 
 
00-future:
 
Replaced the section of "future directions" in R-ints.texi with a stub
for pqR, with no content at the moment.
 
 
00-news:
 
Move NEWS to ONEWS, ONEWS to OONEWS, OONEWS to OOONEWS.  Create new
NEWS.Rd with initial content for pqR.
 
 
00-version:
 
Changes to display pqR version information, including separating the
pqR version from the version of R that pqR is based on. Also updates
some copyright notices, and changes bug reporting address.
 
 
01-Rprofmem:
 
New version of function Rprofmem (and related Rprofmemt) implemented.
See NEWS entry.
 
 
01-cleanup:
 
Miscellaneous code cleanups, including the following:

  o Cleaned up inconsistencies in checks for arity of primitives in eval.c
    Removed checks from functions implementing language features "repeat",
    "while", and "function", consistent with other language features (lack
    of checks does not cause a crash --- missing arguments just appear
    to be NULL).  Changed the check in do_set to the standard form
    using checkArity, with names.c changed to make the arity be 2 rather
    than -1.

  o The "spare" bit in sxpinfo is renamed to "misc", and the documentation 
    in the code and in R-ints.texi is changed to reflect this, and to 
    document that this bit is actually used.

  o The documentation before do_seq in seq.c is changed to be correct
    (seq.int is no longer SPECIAL), and the incorrect reference to
    seq.int in R-ints.texi is removed.

  o The fixup_NaRm function defined in summary.c is moved to match.c,
    where it belongs.  It is now properly declared in Rinternals.h,
    rather than the definition in summary.c being surreptitiously
    referenced as an extern from logic.c.

  o Defined an isRaw macro globally for consistency with other such macros, 
    deleting several local definitions of this.    

  o Fixed problem with recompilation with byte compilation not enabled.

  o Fixed (by a kludge, not a proper fix) a bug in the "tre" package that
    shows up when WCHAR_MAX doesn't fit in an "int".  The kludge reduces
    WCHAR_MAX to fit, but really the "int" variables ought to be bigger.
    (This problem shows up on a Raspberry Pi running Raspbian.)  Also fixed 
    a going-past-end-of array bug (that probably never happened).

  o Code in R-2.15.0 exists for maintaining a cache of primitive objects,
    but this code forgets to ever actually enter a primitve into the cache.
    This is now done (in mkPRIMSXP).

  o Updated R-admin to discuss derived but distributed files (eg configure).

See also entries in NEWS for other mods that merit description there.
 
 
01-inspect:
 
The "inspect" .Internal function was changed to show some details of
pairlist nodes, if SHOW_PAIRLIST_NODES is defined as 1 in inspect.c.
It also shows length and truelength (the hash) for CHARSXP nodes.
Optionally displays details of promises, and now handles R_UnboundSymbol
correctly.

Finally, it no longer produces output with tabs (spaces instead).
 
 
01-omp:
 
Rinternals.h now has a #define for R_OMP_FIRSTPRIVATE_VARS, which
contains a comma-separated list of variables that should usually be
included in the firstprivate part of an OMP parallel construction,
since they are used in macros such as NA_REAL.

The only use of this in the interpreter itself gets deleted by a later
mod, but this mod is retained anyway...
 
 
01-pnamedcnt:
 
New pnamedcnt primitive function for printing named field of object.

See NEWS entry for details.
 
 
01-testing:
 
Eliminated non-deterministic aspect of testing of random number
generators.  Also prints more details on failure.  

See NEWS entry for details.
 
 
02-cons-with-tag:
 
This mod defines a cons_with_tag function that creates a CONS cell
given its CAR, CDR, and TAG fields.  This makes for clearer, more
concise, and faster code when CONS cells with TAG set need to be created.
 
 
02-copy-elements:
 
Defines several functions for use within the R interpreter.

New functions copy_string_elements and copy_vector_elements are now
defined.  Compared to using SET_STRING_ELT and SET_VECTOR_ELT, these
allow copying of multiple elements without error checks on every
element, and sometimes without old-to-new checks on every element.

A new function copy_elements is also defined, for copying elements in
any sort of vector (duplicating non-atomic elements, and using
copy_string_elements).

A new function set_elements_to_NA_or_NULL is defined for doing that.

See also the NEWS item on a bug fix.
 
 
02-epmatch:
 
New functions are defined for finding exact or partial matches, to
replace the existing pmatch, psmatch, and other matching functions
(but pmatch and psmatch are retained, in case anyone uses them).
These functions return 0, -1, or +1 for no match, partial match, and
exact match, allowing any subset of these conditions to be easily
checked for in one comparison.  There is therefore no need for an
"exact" argument as in psmatch.  The new functions should usually be
faster as well (the old psmatch uses strcmp for exact matches, which
might be able to use special machine instructions if they exist, but
since most calls will be for short strings, and early failure to match
is likely the most common result, this is unlikely to provide a
benefit once extra procedure call overhead is accounted for.)

Versions are provided for matching a string to a string, an SEXP to an
SEXP, or a string to an SEXP, called ep_match_strings, ep_match_exprs,
and ep_match_string_expr.

Calls of pmatch are replaced by calls of ep_match_exprs in various
places as part of this mod, and these functions are also used in later
mods (eg, in matchArgs and in do_subset3).

Speedup from using these functions is mentioned in a NEWS entry.
 
 
02-evalv-prim:
 
Two changes to how expressions are evaluated.

First, a facility has been introduced for an expression to be
evaluated in a context in which a "variant result" is allowed - eg, if
the result will be ignored anyway (expression is evaluated only for
side effects), a null result might be allowed.  This is done by
introducing an "evalv" function that is like "eval" but with an extra
parameter saying what variant results are permissible.  This facility
is used for later modifications, with some symbols defined here in
anticipation of these modifications.

Second, calling of primitive functions has been speeded up by copying
relevant information (eg, arity) from the table defining primitives
(in names.c) to fields in the SEXP for the primitive.  This saves
table access computations and also division and remainder operations
to get at the information in the "eval" field in names.c, which is
encoded as decimal digits.

A procedure SET_PRIMFUN in memory.c was surreptitiously changing the
function pointer for a primitive via the function pointer access
macro, PRIMFUN.  A SET_PRIMFUN macro now does this properly.

The types used for pointers for C functions implementing primitives
have been make safer, taking account of C99's specification that one
can convert between all types that are pointers to functions without
loss of information, but not necessarily between a pointer to a
function and a pointer to void.

Code in saveload.c (for loading old workspaces?) creates a primitive
directly, bypassing the mkPRIMSXP procedure.  This seems unwise, since
creation via mkPRIMSXP is apparently needed to ensure protection of
primitives.  Whatever is going on there should not be affected by this
modification, however.

R-ints.texi has been updated to document evalv and variants.
 
 
02-promiseWith:
 
Two related changes.

Created a promiseArgsWithValues function that calls promiseArgs and
then sets the values of the promises created, and a promiseArgsWith1Value 
function that does the same except setting only the value for the
first promise.  Code to do these things appears in several places, so
creating these functions cleans things up (and is needed for later
mods).

The promiseArgsWithValues and promiseArgsWith1Value functions are not
entirely equivalent to the previous code, which set the values of what
it took to be promises without checking that they actually were
promises.  Since promiseArgs doesn't always create a promise for every
argument (it doesn't when the argument is R_MissingArg), this doesn't
seem safe, though there seem to be no examples where a bug actually
arises.  The promiseArgsWithValues and promiseArgsWith1Value silently
skip setting the value for arguments that aren't promises, as will be
necessary when missing arguments do arise.

Also, a problem is fixed with the DispatchOrEval function in eval.c.
Without this fix, some subtle things go wrong with existing features
in 2.15.0, and more serious things go wrong with some later pqR mods.

The issue is that if DispatchOrEval is called with argsevald set to 1
(which indicates that arguments have already been evaluated), if
DispatchOrEval dispatches to a method for an object, it passes on
these argument values without putting them in promises along with the
unevaluated arguments.  Because of this, a method that attempts to
deparse an argument will not work correctly.  It seems possible that
there might also be some other bad effects of not having these
promises.

Here is an illustration:

> a <- 0
> class(a) <- "fred"
> seq.fred <- function (x, y) deparse(substitute(y))
> seq(a,1+2)
[1] "1 + 2"
> seq.int(a,1+2)
[1] "3"

Both "seq" and "seq.int" dispatch to seq.fred, but seq.int calls
DispatchOrEval, which doesn't pass on a promise with the unevaluated
argument.  After the fix, seq.int does the same as seq.  This example
is now tested in tests/eval-etc.R.

Also fixed some formatting in DispatchOrEval, and improved the
documentation for R_possible_dispatch to explain its features used in
this fix.
 
 
03-ISNAN:
 
IF ENABLE_ISNAN_TRICK is defined when pqR is configured (by including
-DENABLE_ISNAN_TRICK in CFLAGS), the ISNAN macro is changed to be
faster for many common cases.  This change relies on the same result
being produced when casting NaN, -NaN, NA, and -NA to integer, which
is true on Intel systems, but not on SPARC systems.  A fatal error is
produced if this is seen to not be true (in which case the define of
ENABLE_ISNANS_TRICK should of course be removed).
 
 
03-contexts:
 
Reorder RCNTXT structure and code in begincontext to maybe make saving
a context faster.
 
 
03-def-COPY:
 
Introduced a facility for making a local copy of R_NilValue, and
potentially other globals.  This is done with LOCAL_COPY(R_NilValue).
Access to the local copy may be faster, partly because the compiler
will know that it isn't being modified.
 
 
03-fast-base:
 
Lookup of symbols defined in the base environment has been sped up by
flagging symbols that have a base environment definition recorded in
the global cache. This allows the definition to be retrieved quickly
without looking in the hash table.  In particular, this speeds up
basic operations such as "+", "<-", "if", and "length".
 
 
03-fast-const-eval:
 
An "eval" of an expression that evaluates to itself (usually a
constant in an expression) has been made faster by quickly checking
for a self-evaluating value by a shift and mask operation, and if the
expression is self-evaluating, returning it immediately, without the
overhead of things like checking for stack overflow.  Depending on the
machine and the compiler, it's possible that the subsequent switch on
expresssion type for non-self-evaluating expressions will also be
faster, due to it having many fewer cases.
 
 
03-fast-spec:
 
Lookup of some builtin/special function symbols (eg, '+' and 'if') has
been sped up by allowing fast bypass of non-global environments that
do not contain (and have never contained) one of these symbols.  The
symbols that are special for this purpose are specified in InitNames
in names.c.
 
 
03-getAttrib:
 
Defines versions of getAttrib that allow faster attribute search when
it is known that no special processing is needed.  Plus other minor
speedups.
 
 
03-inlined:
 
Various inlined procedures were changed to be more efficient.

Several sets of types, represented by 32-bit words with "1" bits
corresponding to included types, are now defined in Rinternals.h. These
allow fast testing for set membership with if ((set >> type) & 1) ...
This is sed heavily in the inlined functions, but may also be used 
elsewhere.

The "length" function was un-inlined, since it's fairly long.
Numerous occurences of code like for (i = 0; i < length(...); i++)
... were replaced by code that doesn't call length many times,
sometimes by saving the result of one call of length, sometimes by
replacing length with LENGTH.  (Though note that LENGTH doesn't work
for R_NilValue!)
 
 
03-install:
 
Detailed speed-up of the "install" function for installing a new (or
old) symbol.  Also put in (currently disabled) code for seeing how
many symbols there are, for tuning purposes.
 
 
03-matchArgs:
 
The matchArgs function, used in the interpreter to match formal and
actual arguments when calling functions has been sped up, and given a
new interface.

One interface change allows the formal arguments to either be given as
a list SEXP (as before), or as an array of C strings, along with a
count of how many strings are in the array.  (If formals are given by
C strings, the SEXP for the formals list parameter should be NULL,
whereas if the formals are given by a list, the pointer for the C
strings should be NULL and their count should be 0.)

Numerous calls of matchArgs are changed to use the interface with an
array of C strings (for example, in the code implementing rep and
seq.int).  These calls were previously preceded by creation of a list
with calls to "install" for all the formal argument names.  Using the
new interface is cleaner and considerably faster.

A second interface change is that if the formals are given by a list
SEXP, tags for the arguments are attached to the actuals list by
matchArgs.  Places where matchArgs is called are changed to no longer
do this themselves.  (Doing this in matchArgs is both cleaner and
faster.)

The new code is also faster in ways unrelated to these interface
changes.

Finally, 38 calls of check1arg(args,call,"x") were replaced with calls
of a new macro check1arg_x(args,call) that should be faster.
 
 
03-parens:
 
Parentheses are make faster by making them SPECIAL.  Also, curly
brackets pass on the eval variant to the last expression, and pass
VARIANT_NULL for earlier expressions.
 
 
03-promise-named:
 
Values of forced promises no longer have NAMED always set to 2.
Instead NAMED for an object is incremented when it becomes the value
of a promise.
 
 
03-promiseArgs:
 
The creation of argument lists for closures is sped up by avoiding an
unnecessary allocation of a CONS cell, in the same way as was done in
my Sep 2010 patch for evalList, which was incorporated into 2.12.0 and
later versions of R.  Also, now uses cons_with_tag in all these routines.
 
 
03-protect:
 
PROTECT, UNPROTECT, etc. have been made mostly macros in most of the
files in src/main.  This applies only to files that include Defn.h
after defining the symbol USE_FAST_PROTECT_MACROS.  If this is
defined, macros PROTECT2 and PROTECT3 for protecting two or three
objects at once are also defined.

This change speeds up numerous operations.
 
 
03-save-alloc:
 
Some binary and unary arithmetic operations have been sped up by, when
possible, using the space holding one of the operands to hold the
result, rather than allocating new space.  Though primarily a speed
improvement, for very long vectors avoiding this allocation could
avoid running out of space.
 
 
03-scalars:
 
Global constants R_ScalarLogicalNA, R_ScalarLogicalTRUE, and
R_ScalarLogicalFALSE have been created, and the interpreter's
ScalarLogical function now returns one of these rather than allocate
new space for every logical value.

To avoid problems with an external C or Fortran routine changing one
of these values (with an incorrect specification of DUP=FALSE even
though it modifies the argument), the values of these constants are
checked after the return of an external function called with .C or
.Fortran, and if they have changed, their values are reset and an
error is signalled.

The bytecode interpreter sets up a similar set of logical constants.
That facility should be merged with this one (perhaps by just calling
the ScalarLogical function in the bytecode interpreter).

Various places in coerce.c were changed to use ScalarLogical rather
than allocate logical values themselve.  This is both cleaner and now
more efficient given the change above.
 
 
03-seq-varop:
 
Several primitive functions that can generate integer sequences (":",
seq.int, seq_len, and seq_along) will now sometimes not generate an
actual sequence, but rather just a description of its start and end
points.  This is not visible to users (except in time and space
savings), but allows for speed up (with other mods) of primitive
operations such as "for" loops and indexing of vectors.
 
 
03-sexprec:
 
The basic sexprec structure for objects is modified here, to allow for
a number of future modifications.  The new scheme is documented in
R-ints.texi.
 
 
03-stringops:
 
Procedures copy_1_string, copy_2_strings, and copy_3_strings are now
defined in utils.c, and used in many places in the interpreter.  These
procedures concatenate 1, 2, or 3 strings, checking for overflow of
the destination space.  They are faster and less error-prone than the
various code sequences they replace (often involving strlen and sprintf).
This gives signficant speed-ups for some operations such as calling
S3 methods.
 
 
03-translate:
 
Speed up character translation a bit somtimes, by doing operations
only when they are actually needed.
 
 
03-vstack:
 
Many calls of vmaxget and vmaxset are replaced by macros VMAXGET and
VMAXSET that do the same thing faster.
 
 
03-zap-isMissing:
 
Removes a call of R_isMissing in the interpeter's evalList function.
This check, done for every argument to a builtin primitive that is a
symbol, is slow, and appears to serve only to produce an error message
that is slightly different (and sometimes less informative) than
simply letting the symbol be evaluated.
 
 
04-coerce-bind:
 
Extensive cleanup in bind.c and coerce.c.

Simple cases of "c" with no names (or names ignored), no conversion,
and no recursion are done more quickly.

The copy_elements procedure is now used where appropriate.

A complete set of XFromY functions are now present in coerce.c (some
were missing).  A copy_numeric_or_string_elements procedure is now
defined in coerce.c, which uses these functions.

Also, fixed a bug where excess warning messages may be produced on
conversion to RAW.  See NEWS entry.
 
 
04-dollar:
 
Access via the $ operator to lists, pairlists, and environments has
been sped up.  The speedup comes mainly from (a) avoiding the overhead
of calling DispatchOrEval if there are no complexities, (b) passing on
the field to extract as a symbol, or a name, or both, as available,
and then converting only as necessary, (c) using the new ep_match
functions instead of the previous local pstrmatch procedure, and (d)
not translating a string multiple times.

An error reporting bug in $ was also fixed.  See NEWS entry.
 
 
04-ifloop-debug:
 
Fixes the "debug" facility.  See NEWS item.

Also cleans up code, and propagates evalv variant to branches of "if".
 
 
04-relop-logic:
 
Logical operations and relational operators have been sped up in
simple cases, and use the new facility for producing a scalar logical
result without allocating new storage.  Relational operators have also
been substantially speeded up for long vectors.  Relational operators
are reduced to either EQOP or LTOP to avoid repetitive code, which
then makes it reasonable to specially treat equal length operands and
operands of length 1.
 
 
04-subscript:
 
Speeds up extraction and replacement of subsets of vectors or
matrices, by speeding up the creation of the vector of indexes used.
Often avoids a duplication and eliminates a second scan of the
subscript vector for zero subscripts, folding it into a previous scan
at no additional cost.  String subscripts are handled more efficiently
by not creating a vector of indexnames when it is not needed, and by
other detailed code improvements.

The previous code duplicated a vector of indexes when it seems
unnecessary.  Duplication was for two reasons: first, to handle the
situation where the index vector is itself being modified in a replace
operation, and second, so that any attributes can be removed, which is
helpful only for string subscripts, given how the routine to handle
them returns information via an attribute.  Duplication for the second
reasons can easily be avoided.  The first reason for duplication is
sometimes valid, but can usually be avoided by, first, only doing it
if the subscript is to be used for replacement rather than extraction,
and second, only doing it if the NAMED field for the subscript isn't
zero.

Also removes two layers of procedure call overhead (passing seven
arguments, so not trivial) that seemed to be doing nothing.
 
 
04-vec-enlarge:
 
Extending lists and character vectors by assigning to an index past
the end, deleting list items by assigning NULL, and concatenation of
character vectors with "c" have all been speded up.  This is partially
from use of copy_string_elements and copy_vector_elements.  Another
gain comes from handling deletion of a contiguous block specially.
 
 
04-vec-subset:
 
Speeds up extraction of subsets with "[", as detailed in NEWS entries.
 
 
05-BLAS:
 
The BLAS routines supplied with R were modified to improve the
performance of the routines DGEMM (matrix-matrix multiply) and DGEMV
(matrix-vector multiply).  Also, proper propagation of NaN, Inf,
etc. is done now.

These routines are probably still not as fast as those in a more
sophisticated BLAS, but will be of benefit to users who do not 
install a different BLAS.
 
 
05-RNG:
 
Improves the performance of the uniform random number generation
routines (which are also used as the base for other generators), and
an unnecessary limitation.  See NEWS entry for details.

The previous code was also rather messy - global references were mixed
with references by argument to the same variables, sometimes concealed
by macro definitions, and the seed was often referenced by pointers
which actually always pointed to the same location, which was also in
some places referenced directly.

A bit of previous code that assumed R integers are exactly 32 bits was
changed to assume only an R integer is at least 32 bits in size.
 
 
05-anyall:
 
Speeds up "any" and "all" by detailed code improvements.
 
 
05-data-frame:
 
The R code for as.data.frame.matrix has been sped up a bit. (Other
mods also have the effect of speeding up this function.)
 
 
05-matprod:
 
Includes the matprod library from github.com/radfordneal/matprod, 
and uses it for the %*% operator when doing so is specified by the
mat_mult_with_BLAS option.  See help("%*%") and help(options) for
details.  

The NEWS item for this is a stub, since it will be combined with
that for a later mod.
 
 
05-pow:
 
I previously proposed a simple patch speeding up squaring, which the R
core team did not adopt.  Instead, in R-2.12.0 they introduced an
inline function R_POW, that checks specially for a power of 2, and
does it as a multiply, otherwise calling the R_pow function.  R_pow
proceeds to check again for a power of 2 at the beginning, and then
check again for a power of 2 just before calling the C pow function.
The R_pow function also contains a check for a power of 0.5, but it is
disabled for recent versions of gcc, to bypass a bug that according to
a comment existed at one time.  Note that the inline R_POW function
will not necessarily be actually inlined by the compiler, and that in
any case the check for a power of 2 is done over again for every
element of a vector being raised to that power, even if the power is a
scalar.

In this new patch, if the power is a scalar, I check for it being 2,
1, 0, or -1, and if so handle it specially.  Otherwise, I call R_pow,
which I changed to not bother checking for powers of 2, and to
actually check for a power of 0.5.  (Since the relevant code has
changed, any buggy compilers still extant probably will compile the
new code OK; if not, they probably compile lots of stuff incorrectly,
since there is nothing unusual in the new code.)

For non-scalar powers, I use R_POW, but change it to a macro, so that
it will definitely be inlined, and have it check for powers of 2 and
1.  (If one is going to do this check when the power is a vector, it
makes sense to tailor it to something other than a vector of powers
that are all the same, since this doesn't seem like a common case.
Some powers of 1 and some of 2 seems plausible in some statistical
applications.)  The macro also allows for the power to be an integer,
slightly speeding up some integer^integer operations.

The speed improvement from this patch depends a lot on the machine
architecture and the compiler.  On machines where memory is much
slower than the processor, checking for a power of 2 every time may
mostly overlap with the a memory fetch or store operation, but one
would not expect this to always be the case.

See also the NEWS item on this.
 
 
05-rowcolSums:
 
Rewrote the internal rowSums and colSums functions to be faster.  Also
changed the R rowSums and colSums functions that call the internal
functions so that they treat the common case where the array is matrix
specially, with less overhead.
 
 
05-sum-prod:
 
Code for the sum and prod functions has been changed to move some
checks outside the inner summation loops.  The effect depends on the
extent to which the unnecessary checks overlap memory fetch
operations, but one would expect signficant speed-ups with some
machines/compilers.

I had previously proposed this modificaton to sum and prod before
R-2.12.0.  That patch was not adopted by the R core team, though they
did swap the order of checking for NA/NaN and checking the na.rm
option, which avoids the worst inefficiency of the previous code in
R-2.11.1.
 
 
05-transpose:
 
The speed of the transpose (t) function has been improved, when
applied to real, integer, and logical matrices.  This is done by
moving pairs of elements, which improves memory access behaviour.

Note that I had previously speeded up transpose with a patch that was
incorporated into R 2.12.0.  This improvement gives an additional
speedup, by up to a factor of about 1.4.
 
 
06-applydefine:
 
Speed up assignment to a subset of a variable by various detailed
improvements to "applydefine" and associated functions in eval.c.
Includes handling "[", "[[", and "R" as special cases, with pre-setup
symbols for "[<-", etc. rather than using "install".
 
 
06-attrib:
 
Speed improvements in attrib.c from detailed code improvements.
 
 
06-contexts2:
 
Defines a revisecontext function, that is used to avoid the deletion
and recreation of a context during the setup for applying a function.
 
 
06-def-nmcnt-macros:
 
Defines macros for using a three-bit nmcnt in the sxpinfo structure in
the header for every object rather than the named field of R-2.15.0.
These macros support a true reference counting scheme, which is
documented in R-ints.texi.  

New versions of NAMED and SET_NAMED are defined for compatibility.
The new macros are actually used only in later mods, not in this one.

The "inspect" and "pnamedcnt" funtions are updated to display nmcnt
properly.
 
 
06-fast-prim:
 
This mod combines several changes, loosely related by their all
reducing interpretive overhead or speeding up primitive functions.

The largest change is that a new scheme is used for quick dispatch of
some unary and binary primitive functions, as described in the
documentation in R-ints.texi.  In particular, this mod includes "fast"
versions of the functions implementing the following primitives
(called do_fast_XXX):
  
  arith (+, -, *, /, ^, %%, %/%)
  math1 (exp, sin, etc.)
  trunc
  abs
  length
  dim
  is (is.null, is.integer, etc.)
  isna
  isnan
  isfinite
  isinfinite
  cmathfuns (Re, Im, etc.)
  logic3 (any, all)
  colon
  seq_len
  sum
  prod

But note that not all calls of such primitives will use the fast
dispatch mechanism.

The evalListKeepMissing function in eval.c now just calls evalList,
with an indicative argument, eliminating code duplication.

Calls of the R_CheckStack procedure in evalv and other places were
replaced with a macro R_CHECKSTACK, which is faster.

The LOCAL_COPY macro is used in several places to (hopefully) speed up
references to R_NilValue.

Evaluation of .Internal calls now pass on the "variant" desired.

Expressions such as \code{all(v>0)} and \code{any(is.na(v))} where
\code{v} is a real vector now avoid computing and storing a logical
vector, instead computing the result of \code{any} or \code{all}
without this intermediate, looking at only as much of \code{v} as is
needed to determine the result.  This is done using the "variant
result" framework.

Similarly, when \code{sum} is applied to many mathematical functions
of one vector argument, for example \code{sum(log(v))}, the sum is
performed as the function is computed, without a vector being
allocated to hold the function values.

Several bugs were fixed, as described in NEWS items.  In particular,
int_fast64_t variables are now used to accumulate integer sums for
"sum" and "mean" in order to avoid overflow.
 
 
06-gc-mods:
 
Many changes were made to the garbage collector and associated
routines in memory.c.  These do not change the general scheme, but
improve it in many ways, some of which are noted below.

Small nodes classes are now distinguished only by size, with CONS
cells being allocated in the smallest class that can contain a CONS
cell, not in a special class.  (Depending on the machine, it is
possible for some vector objects to be smaller than CONS cells.)  See
comments in memory.c for details, also the new version of the
documentation obtained with help(Memory).

Linking of nodes in pages is now done in forward order, not backwards
as before, which should improve cache performance.

The source file size.c has been merged into memory.c, where it
logically belongs.

The mkChar function and related routines were moved from envir.c to
memory.c, where they belong, because of the special treatment of the
global string cache by the garbage collector.

HASHPRI was renamed to HASHSLOTSUSED.

The scheme for using valgrind was revised, and a newer version of
valgrind is now used.

The gc.time function was fixed (see NEWS item).
 
 
06-gram:
 
The parser was changed to improve locality of nodes representing
language objects, which may improve cache performance when
interpreting R code.
 
The paser is now generated with bison version 2.5.  This is not
expected to have any consequences.
 
 
06-objects:
 
Speeds up routines in objects.c, such as GetObject.  Also fixes the
bug mentioned in the NEWS item here.
 
 
06-rm-named:
 
A new function get_rm is now defined, which removes a variable and
returns the value it had had.  See the NEWS item and help(get_rm) for
details.

Many function in base have been changed to use get_rm to reduce
duplication of objects.  Some other code improvements have been
made at the same time.

Two bugs have been fixed, as reported in NEWS.

The lapack.Rout.save file has been changed to match the new behaviour
of svd regarding return of NULL elements.
 
 
06-varop-for:
 
For loops in which the index variable goes through an integer sequence
are now done without actualy allocating a vector to hold the sequence.
This saves both space and time.  This is implemented using the variant
result facility, which is used by ":" and other sequence primitives.
 
 
06-varop-sub:
 
The variant sequence operations that possibly return a range are used
here to speed up subscripting of vectors and matrices.  For matrices,
only the first index (for rows) is currently handled as a range (if
possible). (Handling the column index as a range would be possible,
but would provide a lesser speedup, due to data ordering, and to the
loop over columns being the outer loop.)

A missing row subscript for a matrix is also converted to a range from
1 to the number of rows.

Handling ranges without creating index vectors saves both time and
space.

Note that this change has no effect for accesses via compiled code,
though the compiler could probably be modified to exploit this
feature.
 
 
07-apply:
 
Sped up "apply" in the common case where it is applied to a matrix.
Also clarified the documentation and fixed a bug, as described in
NEWS.
 
 
07-coerce-bind2:
 
The "rbind", "cbind", "c", and "unlist" primitives have been speeded
up for many cases.  A bug in "rbind" has been fixed, as documented in
a NEWS item.

A new copy_elements_coerced procedure numeric and string vectors with
possible coercion, and has been used to replace much repetitive code
that does this.  This replaces the copy_numeric_or_string_elements
procedure from the 04-coerce-bind mod.
 
 
07-math-cleanup:
 
Cleans up the code for mathematical functions in arith.c, speeding
some things up in the process, and preparing for later mods.
 
 
07-scalar-arith:
 
Rreal arithmetic and integer plus/minus on scalars with no attributes
are now done more quickly as special cases rather than by the
general-purpose code.
 
 
07-use-nmcnt-macros:
 
Many uses of NAMED and SET_NAMED are replaced by the appropriate
NAMEDCNT macro (defined in the 07-def-nmcnt-macros mod).

Procedures for setting variables in envir.c have been re-organized,
and changed to increment and decrement NAMEDCNT according to the new
scheme.

The <<- operator no longer duplicates rather than adjusting NAMEDCNT
when the value assigned has NAMEDCNT > 0.

Assignment to a global symbol no longer causes it to be flushed from
the global cache, unless it did not previously exist.  (Flushing is
not necessary when all that changes is the value bound, not whether
and where it is bound.)

The count of hash table entries in use was wrongly maintained in
HashSet in envir.c.  This affected when hash tables were resized, but
not correctness.
 
 
08-DispatchOrEval-change:
 
Added the option of the argsevald argument of DispatchOrEval being -1,
which indicates that the first, but only the first, of the arguments
has already been evaluated.  Used later for "[".
 
 
08-fix-nmcnt-bugs:
 
Several bugs involving incorrect maintanence of NAMEDCNT/NAMED are
fixed here, as detailed in NEWS items.  These fixes use new macros
called SET_VECTOR_ELEMENT_TO_VALUE and SET_VECTOR_ELEMENT_FROM_VECTOR.
Some speed improvements were made too.

A new test script, tests/namedcnt.R, tests these fixes.
 
 
08-helpers-framework:
 
This mod implements the basic framework of the helpers facility.
However, the only functions that may be done in a task are the "row"
and "col" functions (implemented in this mod for testing purposes).
Later mods implement many more operations as tasks that may be done in
helper threads.

General information on the helpers facility is now obtainable with
help(helpers).  In this mod, the information is very minimal.

The --enable-helpers-threads configuration option is now documented
in R-admin.texi.

There is some minimal documentation on the helpers framework in
R-ints.texi.

See NEWS item (and R --help) for new use of environment variables as
alternative to arguments to the R command.
 
 
08-matrix:
 
Speeds up the "matrix" function, as described in NEWS.
 
 
09-arith-tasks:
 
This mod uses the helpers framework to implement pipelined arithmetic
tasks, for operators +, -, *, /, ^, %%, and %/%, and for mathematical
functions of one argument (exp, etc.).  The code is also cleaned up in
various ways.

Note that some operations cannot be done in helper threads because of
the possibility that they will produce a warning message, which can be
produced only in the master thread.
 
 
09-matprod-tasks:
 
This mod implements matrix multiplication using tasks that may be done
in helper threads.

For real matrix multiplication, five tasks are defined, for
zero-result multiplies, matrix dot products, matrix-vector multiplies,
vector-matrix multiplies, and matrix-matrix multiplies.  All but the
first of these tasks have three versions, using non-taks routines in
extra/matprod, using BLAS routines, and using the pipelined task
routines in extra/matprod.

For complex matrix multiplication, two tasks are defined, for
zero-result and normal multiplies.

A new configuration option is introduced for controlling whether BLAS
routines can be called from helper threads (ie, whether the BLAS is
thread-safe), called --disable-mat-mult-with-BLAS-in-helpers.  The
default is to consider the BLAS to be thread-safe.
 
 
09-rowcolsums-tasks:
 
Changed (row/col)(Sums/Means) to use task procedures that can be done
in a helper thread.  Also makes other tweaks.

Fixed lack of error check for .rowMeans, etc. (see NEWS).
 
 
09-set-pend-cmplx:
 
Changes symbol lookup routines to allow lookups that do not wait for
the value to be computed.  Also does some cleanup of these routines.

Modifies the implementation of assignments to use these modified
lookups, and to temporarily increment NAMEDCNT for rhs of complex
assignment to avoid problems when the value of the assignment
expression is used (see bug described in NEWS).  Adds a test of this.
 
 
09-subset-fix:
 
This fixes some bugs with subsetting of lists, as described in NEWS.
Adds tests for these.

 
 
09-subset-par:
 
This mod changes simple forms of indexing of vectors to allow the
vector to not be fully computed, as long as the elements accessed have
been computed.
 
 
09-transpose-task:
 
Do matrix transpose in a task that can be executed in a helper thread
(unless it's a matrix of non-numeric items).  The output can be
pipelined, but not the input.
 
 
09-writetable:
 
The write.table function is modified to allow the data vector to not
be fully computed when write.table starts.  It waits for an element to
be computed only when that element is the next to be written.
 
 
10-future:
 
This mod adds comments on future directions for pqR to R-ints.
 
 
10-hash:
 
Fixes a memory expansion bug reported to R Core (PR 15363), and the
similar problem with rm and get_rm.  Also cleans up the code some
(more cleanup is needed), and uses HASHASH to avoid hash computations
consistently.  Defines a maximum size for the string hash table in
memory.c separately from the maximum size for other hash tables.
 
 
10-no-SETLENGTH:
 
Remove the few uses of the deprecated SETLENGTH macro/function in the
interpreter and in the stats package.  There is still one place it is
used in the recommended Matrix package.
 
 
10-pretty-news:
 
This mod revises doc/NEWS.Rd to be in pretty form for a release,
removing some information that really only belongs in MODS.

The MODS file is also removed here.  It was present before only
because earlier version of some mods used it rather than the mods
directory.  (However, MODS is recreated in release directories.)
 
 
11-newer-news:
 
More updates to NEWS.Rd.  Also changed date in SVN-REVISION,
matching date in NEWS.Rd.
 
 
11-sxpinfo-chng:
 
This mod changes sxpinfo in a major way, splitting 32 of the 64 bits
into a union that differs for vector and non-vector nodes.  This
allows the full 32-bit truelength field to be restored.  The diverse
uses of the "misc" bit are now separated.  The use of the "trace" bit
for memory tracing is no longer possible, since it doesn't exist in
vectors, so the tracemem facility is defunct.
 
 
12-contributed:
 
This branch contains a few mods suggested by "armgong" to get pqR
to work on Windows.
 
 
12-fixes-from-R-Core:
 
This branch contains numerous bug fixes and other enhancements taken
from R-2.15.1 or later versions of R distributed by the R Core Team.
 
 
12-gc-helpers:
 
Changed the garbage collector so it doesn't always wait for all tasks
to complete on full collections.  Instead, it waits only until all
large variables that aren't otherwise marked are not in use and not
being computed.
 
 
12-misc-cleanup:
 
Miscellaneous cleanups, including fix of bug reported on r-devel by
Herve Pages 2013-07-12.  Also gets rid of warning for (-Inf)^(1e16).


 
 
12-namedcnt-cleanup:
 
This mod documents a set of conventions regarding modification of
objects and use of NAMEDCNT in R-ints, and implements changes that
bring pqR closer to following them.  These changes also fix bugs,
generalize operations, and improve performance by avoiding some
duplications.

The KalmanLike and KalmanFore functions were also changed to not
modify shared objects, even if "fast" is TRUE.  This was necessitated
by other changes that broadened when objects are shared.

More types are compatible for [[<-, such as assigning a raw to a real,
and a function to an expression.

The bugs fixed include pqR issues #14 and #15, and all of #16 except
about printing dimnames, which also occur in R-2.15.0 and R-3.0.1.
Also makes illegal constructs like v <- pairlist(1,2,3); v[[-2]] <- NULL,
which are documented to be illegal.
 
 
12-subassign:
 
Cleanup in subassign.c.
 
 
12-variant-enhance:
 
This branch enhances/fixes some things to do with variant returns.
A pending result can now be passed on from sum_math through "sum".
A bug in sum(abs(...)) with helper threads enabled is fixed.
 
 
12-windows-fixes:
 
Changes meant to fix things up for pqR to work on Windows.
 
 
13-helpers-help:
 
This mod provides more detailed user documentation on computations
that can be done in helper threads.
 
 
13-newer-news:
 
Updates to NEWS.Rd, including date, with matching change to date in
SVN-REVISION.
 
 
13-subassign2:
 
More cleanup in subassign.c, include using VARIANT_SEQ for 
subscripts of vectors.
 
 
13-subset:
 
This mod spees up subsetting of arrays of three or more dimensions
with "[" by detailed code improvements.
 
 
14-blas-opt:
 
Further improvements in the reference BLAS routines.

DSYRK improved, which affects performance of R crossprod and tcrossprod.

DGEMM is improved for all cases except when the first but not second
operand is tranposed.

Also fixes the bug illustrate below:

  a <- matrix(c(NA,1,0,1),2,2,byrow=T)
  print(a%*%t(a))
  print(tcrossprod(a,a))
  print(tcrossprod(a))
 
 
14-html:
 
Updates doc/html and other places for pqR rather than old R.
 
 
14-misc-cleanup:
 
Miscellaneous cleanups/optimizations, along with start of new NEWS.

Fixed glitch that would prevent pipelining into MODOP.

Fixed NAMEDCNT bug in assignment of repeated elements to a list array;
added tests for such cases.

Fixed ifelse bug introduced earlier in pqR, and sped it up a bit more.
Also put in S4 check from R-3.0.0.

Now pay attention to MAT_MULT_WITH_BLAS_IN_HELPERS_OK for complex
matrix multiplication.

Fixed bug in reusing operand where "name" attribute not removed.

In interactive session, allow value returned at top level to not
have been computed yet.  Of course, we have to wait for it if it
ends up being printed.

Now warn of dangers of -O3 in R-admin.

Bug and documentation fixes for 'apply' and 'rank'.

 
 
14-names-reorg:
 
This mod splits the R_FunTab table in names.c, that gives all the
builtin functions, into smaller tables found in each source file
defining these builtin functions. This lets the descriptions be placed
near the functions, and also lets these functions be static rather
than extern.
 
 
14-new-helpers:
 
This mod includes a new version of the helpers module that supports
deferred task evaluation even when there are no helper threads, and
associated mods to pqR to accomodate it (with various options for
enabling/disabling).

This is preparation for a later mod that will be able to merge some
deferred tasks.
 
 
14-new-matprod:
 
This mod uses a new version of the "matprod" library.
This version includes the matprod_trans1 and matprod_trans2
routines, useful for crossprod and tcrossprod, but they
aren't actually called yet in this mod.
 
 
14-pqR-logo:
 
Changes the R logo to the pqR logo.  Also changes the README and
R-admin to reference pqR-project.org.
 
 
15-crossprod:
 
Changes in how crossprod and tcrossprod are implemented, to make them
similar to regular matrix multiplies (including pipelining, except no
input pipelining for tcrossprod).  Takes advantage of the new version
of 'matprod'.  (Also note the improved BLAS routines in 14-blas-opt.)
 
 
15-extra-news:
 
Adds some NEWS entries that need to be added here to merge properly,
gets rid of surplus sections, and adds the date of the next release.

 
 
15-matprod-test:
 
Add tests of matrix product operations to "make check".
 
 
15-task-merging:
 
This mod implements a limited facility for sometimes merging a
newly-scheduled task with an existing task.  A new version of the
helpers module that supports this is included.  Configuration options
are updated to support this.  Documentation and NEWS are updated as
well.
 
 
16-t-varop-mm:
 
Creates VARIANT_TRANS, changes "t" to return it, and changes %*% to
ask for it for its operands, thereby allowing t(A)%*%B and A%*%t(B) 
to be done faster and with less memory use (like crossprod(A,B) and
tcrossprod(A,B)).

Also cleans up do_matprod, and fixes a bug.

Updates NEWS.Rd with info on this mod.
 
 
16-tune:
 
Adjusts tuning parameters for use of helpers facilities.
 
 
17-fixes:
 
Various changes/fixes.

Some changes for compatibility with various packages, allowing
more access to internals.

Fixes the following bug:

  f <- function (a) 
  { 
    x <- a
  
    function () { b <- a; b[2]<-1000; a+b  }
  }
  
  g <- f(c(7,8,9))
  
  save.image("tmpimage")
  load("tmpimage")
  
  print(g())
  
where the result printed was 14 2000 18 rather than 14 1008 18.

Fixes bug in prod with integer vector containing NA, eg prod(NA).

Cleaned up code in R_AllocStringBuffer, avoiding potential segfault.

Fixed lack-of-protection bug in mkCharLenCE (showed up in checks for
package cmrutils), other improvements in CHARSXP hashing stuff, made
R_StringHash local to memory.c.

Fixed a problem with xtfrm demonstrated by the following (and
affecting package "lsr"):

  f<-function(...) xtfrm(...); f(c(1,3,2))

Also made related change to "range" to probably make it more robust
(though no actual bad behaviour is apparent).

Fixed bug in maintaining NAMEDCNT when assigning to a variable in
an environment using $ (showed up in check of package 'plus').

Changed the behaviour of "$" when dispatching so that the unevaluated
element name arrives as a string, as in R-2.15.0.  This behaviour is
needed for the "dyn" package.  The issue is illustrated by the
following code:

  a <- list(p=3,q=4)
  class(a) <- "fred"
  `$.fred` <- 
    function (x,n) { print(list(n,substitute(n))); x[[n]] }
  print(a$q)

In R-2.15.0, both elements of the list printed are strings, but in
pqR-2013-12-29, the element from "substitute" is a symbol.  Changed
help("$") to document this behaviour, and the corresponding behaviour
of "$<-".  Added a test with "make check" for it.

Fixed bug that causes the code below to create a circular data structure:

  { a <- list(1); a[[1]] <- a; a }

Fixed bugs such as that below:

  a <- list(list(list(1)))
  b <- a
  a[[1]][[1]][[1]]<-2
  print(b)

Added tests for such bugs.  Introduced a variant scheme into subassign
that may help for further cleanup of subassign/applydefine, but is at
present only used minimally for this fix.

Fixed a bug where unary minus might improperly reuse its operand for
the result even when it was logical - eg, -c(F,T,T,F).

Fixed the following bug (also present in R-2.15.0 and R-3.0.2):

  x <- t(5)
  print (x %*% c(3,4))
  print (crossprod(5,c(3,4)))

The call of crossprod produced an error, whereas the corresponding
use of %*% did not.  

In pqR-2013-12-29, this bug also affected the expression t(5) %*% c(3,4),
since it is converted to the equivalent of crossprod(5,c(3,4)).

Added an option (currently set) for pqR to ignore incorrect zero
pointers encountered by the garbage collector (as R-2.15.0 does).
This avoids crashes with some packages (eg, 'birch') that incorrectly
set up objects with zero pointers.

Now use the ISNAN trick (if enabled) only in the interpreter itself, 
since the macro implementing it evaluates its argument twice, which
doesn't work if it has side effects (as happens in the ff package).

Fixed bug in pairlist element deletion.  Added tests in subset.R
for such cases.

Redefined "fork" to "Rf_fork" so that helper threads can be disabled
in the child when "fork" is used in packages like "multicore".  Took
out previous pqR mods to the "parallel" package that did this just for
it, in favour of using this more universal scheme.

Added apparently missing PROTECT of third argument in setAttrib.  Not
protected by caller in lengthgets, for example, though the fact that
the second argument is a symbol there means no actual bug arises.  The
protect is also missing in R-2.15.0 and R-3.0.2.

Made changes along lines suggested by Yu Gong to fix problems with
building for Windows.

Added kludge to fix problem with making as shared library when
multithreading is disabled.

Fixed bug that sometimes resulted in task merging being disabled when
it shouldn't have been.  Cleaned up some other things with helpers
options.
 
 
17-mods:
 
Various mods and documentation changes.  Some are related to
reliability, but are not actually bug fixes.

Extended the check for a foreign routine changing TRUE, FALSE, or NA
to .Call and .External (was only for .C and .Fortran).

Added a test helpers.R that checks that results of vector/matrix
operations are the same with or without multithreading/merging.

Added a "create-configure" script for creating "configure" from
"configure.ac".

Added more documentation on NAMED to R-exts.

Rewrote the INSTALL instructions.

Updated mods/README to give better instructions on how to produce
a release branch.
 
 
17-year-2014:
 
Changes needed since pqR copyrights are now 2013-2014, and 
related mods.
 
 
18-new-news:
 
New section of NEWS for upcoming release.
 
 
19-doc:
 
Documentation updates.

help(diag) now documents what really happens with names, and
that type is double if not complex.

help(c) now documents what happens with names, including
the use.names argument.

help(Arithmetic) now documents the what may happen when an operand 
is NA or NaN, or both are.

R_HELPERS and R_HELPERS_TRACE now documented in "environment
variables"; other doc updates for helpers.

Removed incorrect info on PP stack from help(Memory).

Documented R_DEBUGGER and R_DEBUGGER_ARGS in EnvVar.Rd.
 
 
19-fixes:
 
Miscellaneous bug fixes.

Fixed a lack of protection bug in "log" when it produced a warning.

Fixed an out-of-bound memory access in chull that valgrind reports 
(but which is likely to be innocuous).

Fixed bug in "foreign" package that showed up on systems where
the C "char" type is unsigned.

Fixed stack imbalance bug in assignment to arrays with zero-length
subscripts.

Fixed problem with news() due to pqR version numbers being dates.

Changed the internet.R test to avoid looking at CRAN's html code,
which is subject to change.  Looks instead at a test file at 
pqR-project.org.

Fixed argument error checking bugs in gevents.c.

Fixed problems in reg-tests-1b test script, related to making it
fail gracefully on systems without enough memory for xz compression.
Included a reg-tests-1b.Rout.save to compare with.

Fix bug with lang[23456] not protecting all its arguments.  Also
clean up code (no bug) for list[2345].

Fixed bugs (also in R Core versions) with lack of protection in
sort.c and deriv.c.

Fixed stack imbalance bug illustrated by anyDuplicated(c(1,2,1), incomp=2)
which is also in R-2.15.0 and R-3.1.0.  (It exists but is not reported
when the base package is byte compiled.)

 
 
19-fixes-from-R-core:
 
Bug fixes taken from R core releases after 2.15.0
or from a PR at r-project.org.

Fixed PR 14933 (let "infinity" convert to Inf) as in
R-2.15.1.

Fixed PR 14883 (incorrect generic for backsolve) as in
R-2.15.1

Fixed PR 14847 (bug in get_all_vars) as in R-2.15.1.

Fixed problem with mcmapply not parallelizing when number of jobs 
is less than number of cores, as in R-3.1.0-patched, except (unlike
R-3.1.0-patched) don't try to parallelize with only one core.

Fixed bug in dev.set argument checking, as in R-2.15.1.
 
 
19-mods:
 
Various mods, motivated by compatibility, desire to improve checking, etc.

Minor cleanups (eg, remove unused variables).

Set an unset random seed from the R_SEED environment variable, if it
exists (otherwise from time and process id as before).  Allows for
reproducible checks of packages without changing them.

Rdiff now ignores valgrind output when doing a comparison.  The Rdiff
command unsets R_DEBUGGER so that it won't produce valgrind output
itself if R_DEBUGGER was set to valgrind.

Creation of a matrix with diag is now compatibile with R-3.1.0 w.r.t.
expressions like diag(list(2,3,1)).
 
 
19-new-pkgs:
 
New version packages in "extra".

New 'matprod' and 'helpers' with minor cleanups (no functional effect).
 
 
20-new-news:
 
New section of NEWS for upcoming release.
 
 
21-apply-dots:
 
Mods to avoid passing ... to functions called from the apply family
(apply, lapply, vapply, rapply, and eapply) when ... consists of nothing.

This reduces overhead, and sometimes will allow fast handling of
primitives in pqR (eg, sum).

Note that "apply" is in R, for which this may not help much, while
the others are in C.  

Also cleans up do_missing.
 
 
21-debug:
 
Debugging stuff.

Introduced R_ABORT to get immediate core dump.

Introduced R_BIT_BUCKET to direct output previously always going to /dev/null.
 
 
21-dotcode:
 
Use R-2.15.2's version of .C, etc.

Delete support for "converters" dropped in R-3.0.0.

Make other updates for pqR, including copying of all length-one
vectors, since these might be constants.  Updated documentation
to reflect this, and say what functions give unshared values.


 
 
21-int-overflow:
 
Use more robust form of check for integer overflow.  Addresses
R Core bug 15774 (fixed in R-3.1.1), but in a different way,
using int_fast64_t values.
 
 
21-lookup:
 
Speed up variable lookup by unrolling loop that looks down the chain
of bindings.  

Speed up setting special symbol flag similarly.
 
 
21-manual:
 
Modifications to the R-exts and R-ints manuals, to correct wrong information.

Updates the section on "Finding and setting variables".

Updates the example of numerical derivatives to fix bug.

Fixes another bug in an example in R-exts.
 
 
21-misc-cleanup:
 
Miscellaneous mods for (mostly) minor speedups, code cleanliness, or bugs.

Slightly sped up evalcount updates in eval.c

Slight cosmetic changes to license(), plus pqR URL added, plus fixed
wrong file name.

Changes to model.frame, na.omit, na.exclude, that clean up code
and fix bug that na.omit of a data frame with zero rows has one row.
Also fixed by R-core (with slightly different code) (PR 15399) in
R-3.0.2.

Removed redundant (I hope) initial setting of R_Visible from primitive
data in evalv, and slightly sped up final setting.  Did same for .Internal
(in names.c).

Changed creation of assignment symbols in applydefine to use predefined
symbols rather than look at printname.

Fixed performance problem in logic.c and summary.c from PR 15798
(differently from fix by R Core).  Wider implications addressed elsewhere.

Now use Seql for exact comparison in get1index.

Sped up Rf_length for pairlists.

+logical now converts to integer.

Use copy_3_strings in cross_colon.  Document before its definition that
R_AllocStringBuffer allocates an extra byte for the terminating null
(apparently not realized by someone who updated cross_colon in R-3.0.1).

Be more cautious in SET_VECTOR_ELEMENT_FROM_VECTOR.  Probably was a
bug there, though can't so far construct an example due to namedcnt getting
incremented for other reasons.

Added vmaxget/set in numeric_deriv (as in later R Core releases).

Changed how namedcnt is maintained for lists in seq.c, subassign.c,
and subset.c.

Got rid of NonNullStringMatch.

Cleaned up paste, including getting rid of a vmaxset/get error that
would eat up space, and some speed improvements, including getting
rid of unnecessary call to PrintDefaults.

Cleaned up substr, including fixing bug (reported at PR 15910), and
speeding it up, particularly when extracting a small substring from
a large substring (also saves memory in that case).

Cleaned up substr<- and fixed bug similar to that in substr.  Should
be a bit faster.

Use unhashed environments for source references.

Un-hide R_inspect and R_inspect3 so they can be used when debugging
packages.
 
 
21-remove-stuff:
 
Remove some defunct stuff.

Removed all the code for R_MEMORY_PROFILING.
 
 
21-scalars:
 
Modifications to how scalars (vectors of length one) are handled.

Introduces two versions:  ScalarReal and ScalarRealShared, etc.
Many uses in interpreter converted to shared versions.

No longer inlines these, except except ScalarLogicalShared.

Defines R_NilValue as a constant, rather than allocate it at the start.
Created a new const-objs.c source file for such constant objects.

Makes the logical constants be constant objects.

Makes real 0 and 1 be constant objects when created with ScalarRealShared.

Makes "rep" always return an unshared object.

Fixed a bug in numericDeriv that was found as a result of failure after
real constants were created.
 
 
22-gc-old-to-new:
 
Set "prev" field in nodes to zero to indicate that they are
already in an old-to-new list, and hence don't have to be
moved again.

Also, gets rid of error checks on first arg of SETCAR, SETCDR, etc.,
which seem redundant, given that a memory access error will result.

Makes SETCAR a macro in the interpreter, so a call can be avoided
when the node is already in the old-to-new list.
 
 
22-more-scalars:
 
More definition and use of the scalar constants.

Serialize/unserialize now use a flag to indicate a constant, which
is restored as the same constant.

Other optimization also done in serialize.c, including eliminating
tail recursion in ReadItem.

Define one-element pairlist constants.

Modifed matchArgs as a result to avoid writing to supplied arg list,
which might be a read-only constant.
 
 
22-remove-stuff:
 
Get rid of remove memory profiling stuff, decl for R_VariantResult, LOCAL_COPY.
 
 
22-subset-revision:
 
Changes to subset.c that clean it up and speed it up a bit.
 
 
22-var-dotcode:
 
Introduces a variant result for .C or .Fortran, that returns only
one element of the list if it is the only one that is named (as
a one-element pairlist).

Avoids allocation of the names vector, and will in future provide the
possibility that the C or Fortran routine might be done in a helper
thread.  Also avoids conversion of data that will be ignored.
 
 
23-applydefine:
 
Modifications to complex assignment code (the "applydefine" function).

Simplifies code by getting rid of VARIANT_MUST_COPY, and removing
unnecessary duplication in applydefine.  

Fixes the following bug (and related bugs):

  a <- list(list(1+1))
  b <- a
  attr(a[[1]][[1]],"fred")<-9
  print(b)

Tried to get rid of duplicate in EnsureLocal.  This needed some mods
in length<- and slot assignment for S4 methods.  It turns out that
package Matrix (version 1.0-6) also relies on this duplication and on
the unmodified slot assignment (which it shouldn't really do), so this
has been disabled (but the duplication is now done outside EnsureLocal, 
and the disabled code is kept).  The mod to length<- is kept, and it 
is cleaned up and sped up otherwise as well.
 
 
23-extra-sub:
 
Correct performance bugs regarding "extra" string subscripts.

Fixed bug causing duplication of vec when v["x1"] assigned to below:

   vec <- rep(1.1,1000); names(vec) <- paste0("x",1:1000)
   vec["x1"] <- 9

Fixed performance bug reported on r-devel on 2010-07-15 and 2013-05-08:

   x <- c(A=10L, B=20L, C=30L)
   subscript <- c(LETTERS[1:3], sprintf("ID%05d", 1:150000))

   > system.time(y1 <- x[subscript])
      user  system elapsed
   111.991   0.000 112.230

The fix only speeds up extraction, using such invalid subscripts when storing
is still slow.
 
 
23-more-constants:
 
More things made constants.

Declares constants with LibExtern rather than extern.

Makes R_UnboundValue a constant.

Makes ENCLOS(R_EmptyEnv) == R_EmptyEnv, so can slightly speed up loop
in findFun.
 
 
23-more-dotcode:
 
More improvements to dotcode.c

Duplicates scalars only when they change.

Fixes possible protection bug in do_dotCode.

Implements parallel execution in helper threads, in some circumstances.

Updates help(.C) to reflect mods.

Allows character arguments with DUP=FALSE, duplicating them anyway.

Rationalizes the "checkTypes" code in do_dotCode, which made no sense
(had code to coerce which apparently could not possibly be executed).
Enables registration with type checking for str_signif, with ANYSXP
for the first argument (which previously failed).
 
 
23-more-gc-mods:
 
Further improvements to the garbage collector.

Some local code changes, optional (set) removal of excessive error checks.
 
 
23-objects:
 
Improvements to S3 method dispatch, particularly to speed up
the case where there is no method to dispatch to, but also
other improvements.
 
 
23-prim-formals:
 
Make "formals" work for primitive functions.  Motivated by
rep.int becoming primitive, and being used in an example
for Vectorize, which uses formals.
 
 
23-seq-rep:
 
Updates to the "seq" and "rep" functions, including changes from R
Core releases.

Adds checks to seq.int for from, to, by being of length 1 (as in
R-2.15.1, but more cleanly).

Changed implementation of rep.int to be closer to that of R-2.15.2
(same as R-2.15.3).  But further mods, with further performance
improvements, eliminate just about any resemblence to the code from
R-2.15.2.

Made rep.int a primitive, with a "fast" interface.

Made rep and rep.int doable in a helper thread.
 
 
24-copyright:
 
Updates copyright notices for files changed in 2014.
 
 
24-misc:
 
Miscellaneous updates.

Be more cautious regarding string comparisons involving NA_STRING.

Have forcePromise protect its arguments

Introduces IS_BASE to check slightly more quickly whether an
environment is either R_BaseEnv or R_BaseNamespace.

Puts some of FindVarInFrame3 into FindFun.

Speed tweak in math1.

Major revamp of details of how builtins are handled in evalv, plus
other evalv cleanup.  Uses alloca if possible to avoid always allocating
space for a context when often not needed.

DUPLICATE_ATTRIB in arithmetic.c now doesn't do it if attributes
are already the same.

Make any(isna(x)) faster by adding several elements of x together
and checking sum.
 
 
24-new-news:
 
New NEWS section for mods since 2014-06-19.
 
 
24-scalars-gc:
 
Mods in memory.c regarding get_free_node and the ScalarXXX functions.

Also defines allocVector1RAW, allocVector1LGL, allocVector1INT, and
allocVector1REAL, and uses them throughout where appropriate.

The ScalarXXX are again made inline.
 
 
25-char-sym-gc:
 
Revision to how charsxp and symsxp are handled, in GC and elsewhere.

Fixes charsxp cache to use ATTRIB field unconditionally, removing other code.

Now does simple check for CHARSXP in DO_CHILDREN in gc.

Changes a symsxp to have a nextsym field, getting rid of the
list fof syms in R_SymbolTable in favour of linking by that field.
 
 
25-direct-return:
 
Implements "return" directly, most of the time, using the variant
result mechanism, which should be faster than longjmp, etc.
 
 
25-eval-overhead:
 
Changes to reduce overhead in eval.

Splits evalv into small part that handles constants
that calls larger part (evalv2).

Creates and uses dotdotdot_error to move some code
out of eval (and elsewhere) to make for more compact code.
Also, same for unbound_var_error and arg_missing_error.

Changes applyClosure and its calls so that no supplied environment is
indicated by NULL, not R_NilValue or R_BaseEnv.  The use of the latter
worked only because of peculiarities of the present implementation of
the base environemnt.
 
 
25-from-2.15.1:
 
This mod incorporates features from R-2.15.1 and later R Core releases.

The "methods" package is now taken from 2.15.1, with a small 
mod for pqR.

The "utils" package is now taken from 2.15.1, with several
mods and additions for pqR.

Slight update to configure.ac from 2.15.1.

Now uses the share/texmf/tex/latex/jss.cls file from 3.1.1.

Now uses m4/java.m4 from 2.15.3.

Now uses m4/R.m4 from 2.15.3.  Supposedly fixes Objective C/C++ problem for Mac.

Now uses tools/config.guess and tools/config.sub from 3.1.1 (actually FSF).

Change to Makefile.in (deleting svn-vignettes) following 2.15.2.

Changes to graphapp, fixing a bug (from 2.15.2).

Take extra/tzone from 2.15.3.

Take extra/xdr from 3.1.1.

Updates to src/gnuwin32 taken from 2.15.1 and 3.0.0.

Added R_GetCurrentSrcref and R_GetSrcFilename from 2.15.1.

Added show.error.locations from 2.15.1.

The "tools" package is now taken from 2.15.1, with several mods
for pqR.

Take "datasets" package from 2.15.1.  Only one slight mod from 2.15.0.

Take "grDevices" package from 2.15.1.  This has the effect of doing
the following change from the 2.15.1 NEWS:

    colorRamp() (and hence colorRampPalette()) now also works for the
    boundary case of just one color when the ramp is flat.

Take "compiler" package from 2.15.1 (only slight changes from 2.15.0).

Change pmin/pmax for 0-length args, as in 2.15.1.

Change "exit" to "_Exit" in parallel package, similarly to
what is done in 3.1.1-patched.

Put in the mod from 2.15.3 to get plots to work with newer
versions of cairo.
 
 
26-arith:
 
Localized cleanup and speed improvements in arithmetic.c.

Do integer multiply of scalars in the fast section.
 
 
26-debug:
 
Fixes and speedups for debugging.

Fixes the following bug:

  g <- function () { A <<- A+1; function (x) x+1 }
  f <- function () (g())(10)
  
  A <- 0; f(); print(A)
  
  debug(f);
  A <- 0; f(); print(A)
  
in which stepping though f after debug(f) results in A having the 
value 2 rather than 1.

Now looks at deparse.max.lines when exitting debug of a function
as well as when entering.  Also, execClosure has parallel code
to applyclosure, though it's not clear that it is ever executed.

 
 
26-misc:
 
Miscellaneous changes.

Replaced can_save_alloc with alloc_or_reuse.

Clean up R_LookupMethod and its uses.

Introduce and use installed_already.

Convert some eval's to forcePromise's.

Fiddle with use of forcePromise vs. forcePromisePendingOK, and
eliminate duplicate code in these two functions.

Changed a reference in "methods" to R_NilValue that should be
to R_EmptyEnv.

Merges LISTSXP, LANGSXP, and DOTSXP code in duplicate1.  No
longer duplicates top-level attributes twice.

Fixed the following bug (where the last stmt failed with an error):

   p <- pairlist(1,2,3,4); dim(p) <- c(2,2); p[1,1] <- 9

Cleaned up now-unused "variant" in subassign.c.

Moved some (not all) remaining do_ declarations from names.c
to other source files.

Changed tuning parameters for GC, and introduced supplemental
criterion based on recent allocation sizes for setting R_VSize.

Fixed bug reported on r-devel, 2014-09-02, by Thomas Petzoldt and
Karline Soetaert.  Three routines affected:  nlm, uniroot, optimize.

Fixed a pqR bug involving expressions like t(x) %*% y when y
is an S4 object.

Tweaked sort.c to not do (innocuous) out-of-bounds array access.
 
 
26-new-var:
 
Modifications to the variant result mechanism.

Defines a VARIANT_PASS_ON macro to isolate the part of
a variant that should be passed on by "{", "if", etc.
 
 
26-noreturn:
 
Mark error procs as "noreturn" if possible, either with C11
facility or the gcc attribute.  Similar thing done in 3.0.1, 
but only for gcc.

Changed numerous bits of code where things were done only
to avoid warnings due to nonreturn when -Wall used.  Also
did a few other cleanups (eg, removing unused variables).
 
 
26-sym-binding:
 
Implement a scheme to save the last binding found for a symbol in an
unhashed environment in the SEXPREC for the symbol (two new fields).
This may usually avoid linear searches for symbols in local environments.

Also (sometimes) records in each symbol the last (usually) unhashed
environment in which it was NOT found, to speed up failing searches
(on the way to a global binding).  Currently records and looks at the
environment of the failed search only when searching for a function,
only for an unhashed environment, and only if the function is
eventually found someplace (or is for an S3 method).

Defines new findVarInFramePendingOK function.

Adds a new var-lookup test.

Adds .C, .Fortran, .Call, .External, .Internal to the special symbol list.

Tweaks tuning of loop unrolling in SEARCH_LOOP.
 
 
27-copyright:
 
More updates to copyright dates, etc.
 
 
27-eval-overhead:
 
More playing around to reduce the overhead of "eval".
 
 
27-more-news:
 
Further additions to the NEWS.Rd file.  Also updates README to
mention later R Core releases.

 
 
27-var-loc-assign:
 
Implement a scheme to avoid new allocation in statements like
v <- exp(v), v <- -v, v<-v+1, and v<-2*v, when v is unshared and 
hence can be reused.
 
 
28-applydefine:
 
Modifications to do_set for complex assignments, replacing the
old applydefine function (which is kept around for comparison).

Also, added a codePromises option for deparse, and NA option for
evaluate in dump, which goes with these being needed for better
error display in the new scheme.

Make deparsing for errors use the new codePromises option.  Changed
all the primitive replacement functions (eg, length<-, environment<-,
[<-, [[<-, $<-) to use errorcall, and otherwise rationalized error
handling in various places.  Modified "try" and "traceback" to use 
the codePromises option for deparsing.  Note that this improves
traceback output for errors like the following:

  `f<-` <- function (x,value) x[1,1] <- value
  a<-1
  f(a)<-rep(3,100)
  traceback()

Updated the saved output of reg-tests-2.Rout and reg-tests-1b.Rout
to show new error messages.

Created a new test set, assignperf.R, which tests whether complex
assignments avoid duplication when they should (and incidently does
some correctness tests).

Makes variable lookup and creation return (sometimes) the binding
cell used, in R_binding_cell, so that short-cuts can sometimes be
taken.

Fixes a latent bug in byte-code interpreter activated by presence
of promises with NAMEDCNT == 1.  Should also speed it up a bit.

This mod also has some general updates to NEWS.Rd.
 
 
28-const-optional:
 
Make constant objects be actual read-only constants only optionally
Was thought to perhaps be the source of the problem with RStudio,
but seems it was't.  But code is still kept, with the option for
constant objects to be read-only currently enabled.

The real problem with RStudio seems to be that R_NilValue, R_EmptyEnv,
and R_UnboundValue are no longer variables.  This is now fixed, with
them being declared as variables before being redefined as macros
in Rinternals.h, and initialized as variables after being undefined
in const-objs.c.

There are also other cleanups to do with constant objects.
 
 
28-dupF-fix:
 
Fixes problem with improper use of DUP=FALSE in 'base' and 'stats',

In particular, fixed findInterval, and also changed it to set HELPER
to TRUE (except for small instances).

 
 
28-matmult-na:
 
Changes to whether BLAS is used to do matrix multiplies, to mimic R
Core behaviour so far as it makes any sense at all.

Changes configure.ac to be more explicit about BLAS/LAPACK.

Changes R-admin to stop falsely claiming that vecLib is the default on
OS X.  More changes as well.

Takes vecLibg95c.c from R-2.15.2, for change to accommodate recent 
OS X versions.

Replaces configuration options --disable-mat-mult-with-BLAS-in-helpers
and --disable-mat-mult-in-BLAS-by-default by setting of variables
BLAS_in_helpers and mat_mult_in_BLAS.
 
 
28-new-lapack:
 
Uses newer LAPACK routines, as in R-3.1.1, but doesn't change the
interface to them (which went from .Call to .Internal in R-3.0.0).
 
 
28-not-lvalue-macro:
 
Defines a NOT_LVALUE macro that disallows use on the left side
of an assignment, and uses it to make the macros for CAR, CDR, 
etc. safe from assignment bypassing the old-to-new check even
when USE_RINTERNALS is defined.  

Also fixes two uses of this that recent mods had introduced.

These functions along with REAL, etc. are now defined as static inline
functions for user code, avoiding procedure call overhead for these
operations.  Error checking as before is maintained.
 
 
28-stackcheck-fix:
 
Fixes a problem with checking for C stack overflow, which occurred
when the fallback method was needed for determining the start of the
stack, and a stack check was made when very little stack was used
(which was incorrectly diagnosed as stack overflow).  Occurred in the
check for the Matrix package when using gcc on SPARC Solaris, after
pqR was changed to reduce stack usage.

Also cleaned up the relevant code in other ways.
 
 
28-undo-context-chng:
 
Changed the order of fields in the "context" structure
back to what it was, since RStudio relies on this order.
 
 
29-cleanup:
 
Clean up code that gives (valid) warnings from Mac compiler.

Also clean up from results of clang static analyser.

Fixes adapted from PR 15990 (Karl Millar).

Fixed bug in initialization of user-supplied random generators.

Plus fix a few other bugs, etc.

Tuned rowSums.

Fix for use of Accelerate in Yosemite, as in R Core patch.

Changed coerceVector and asCharacterFactor to protect their arguments.
This is assumed for coerceVector in stats/src/port.c

Made numerous fixes where objects weren't properly protected, mostly
associated with calls of "install".

Added some internal error checks for symbol definition/lookup and
attribute setting.
 
 
29-diag-from-3.0.0:
 
Version of diag for creating diagonal matrix in C, adapted 
from R-3.0.0.
 
 
29-rel-news:
 
Final updates to NEWS.Rd for next release, and other documentation
changes.

 
 
29-speed-tweaks:
 
Some additional tweaks to speed things up.

Defined FIND_VAR_PENDING_OK macro for use in symbol evaluation in eval.

Sped up "for" by using binding cell when possible.

Disabled underflow check in the fast version of UNPROTECT used in the
interprete.

Tweaked threshold for deferred evaluation of arithmetic operators.
 
 
30-bison:
 
Runs "bison -l o xxx.c xxx.y" for gramRd and gramLatex to get versions
with new version of bison.
 
 
30-news-doc:
 
Updates to NEWS and documentation, following release of 2014-11-16.

 
 
31-apply-fix:
 
Fix problems with apply, lapply, vapply, and eapply, in which the
index is changed in a way that affects applying functions that create
functions, and also trashes saved warnings (for lapply, vapply, and
eapply).  Adds a new test for this problem, and generally for the
apply functions.
 
 
31-cleanup:
 
Miscellaneous fixes.

Fixes bug in which updates like a <- -a could sometimes modify a locked binding.

Fix bug in definition of PROTECT, etc. that shows up when compiler gcc 4.8
optimizes.

Changed DUPLICATE_ATTRIB macro in arithmetic.c to call version in memory.c 
if object bit set - just in case may be necessary for S4 objects.

Fixed protect bug regarding R_print.na_string and R_print.na_string_noquote.

Fixed protect bug around call of applyClosure_v in eval.
 
 
31-gc-mods:
 
Modifications to the garbage collector.

Small tweak to process nodes more often, possibly improving cache performance.

Scan symbol table first, and forward pointers from symbols directly, avoiding
the need to forward the symbol itself.
 
 
31-helpers:
 
New version of helpers module, with slight fix to avoid technically
incorrect form of atomic write (though accepted by gcc).
 
 
31-kalibera:
 
Fixes from Tomas Kalibera (sometimes with slight tweaks).

Lots have to do with lack of correct protection.


 
 
31-speed-tweaks:
 
Tweaks in various places to speed things up.

Defines FINDFUN macro for use in eval, to often avoid overhead
of calling findFun.

New faster version of the string hash function.

Faster indexing with [[ when index is a vector of numbers (avoids
creating names attribute).  Used in base::apply now, so speeds it up.


 
 
32-no-fast-binary:
 
Modifies primitives that are currently BUILTIN with a binary
"fast" interface to instead be SPECIAL, and then simplifies
the fast interface to handle unary calls only.

This may improve speed a bit, and also prepares for later
improvements.

 
 
32-no-parens:
 
Eliminate parentheses from the abstract syntax tree for expressions
that are the operands of binary or unary operands, when the
parentheses are not redundant (and hence will be put in by the
deparser).

Made slight modification to a test in the 'codetools' recommended
package to accomodate the removal of parens.
 
 
33-kalibera-fixes:
 
More fixes from Tomas Kalibera, via R Core.
 
 
33-kalibera-opt:
 
Optimizations from Tomas Kalibera, via R Core version.


Faster installChar procedure when symbol name is already a CHARSXP,
from r66478.  Modified Tomas's installChar to accomodate pqR changes,
and avoid code duplication with install.


Tweaked R_loadMethod to skip s_generic.  r66097
Tweaked R_loadMethod to sometimes avoid string compare.  r66098


Adapted some of Tomas's tweaks from r66388.


Adapted some of Tomas's changes in r66693, plus fixed a couple of
my bugs in nearby code.


Adapted some of Tomas's changes in r66713.
 
 
33-misc:
 
Miscellaneous small changes, to do with debugging.

.Internal(inspect(symbol)) now displays the LAST... fields.

Can now disable PROTECT macros, in favour of procedure version that
now checks for protecting object of type NILSXP that isn't R_NilValue.

gctorture now causes FULL garbage collections on each allocation,
as documented.
 
 
33-new-ISNAN:
 
New approach to ISNAN, ISNA, etc.  Assumes IEEE floating point double
corresponds to 64-bit int in consistent endian way.  Implements these
as static inline functions on that basis, using union.  No longer any
need for ENABLE_ISNAN_TRICK, since this should work on all current
processors (any with consistent endianness).
 
 
33-static-boxes:
 
Creates and uses the apparatus for putting scalars in static boxes.

Boxes used and created in arithmetic, math1, and subset([).

Boxes used in relop.
 
 
34-class-opt:
 
Improvements to S4 code.  Note that other improvements are in 33-kalibera-opt.
 
 
34-cleanup:
 
Some code cleanups, which possibly, though not likely, have effects.

Now clear fields of special symbols on gc.

Got rid of direct mkSYMSXP calls for ..d.

Fixed memory leak for Windows in sysutils.
 
 
34-eval:
 
Optimizations to eval and related things.

Introduces EVAL and EVALV inline functions for partially-inlined eval.
 
 
34-kalibera-fixes:
 
And yet more fixes from Tomas Kalibera, via R Core.
 
 
35-more-opt:
 
More optimizations.

Use installed_already and forcePromise in methods_list_dispatch.

Got rid of the conditional use of the global cache (now always used),
since it gets silly maintaining the alternative (which is never tested).

Got rid of conditional use of fast base cache lookup.

Revised findFun and FINDFUN.  Now should be faster for functions in
packages that don't see the global cache.

Created and used integer_to_string function - sprintf seems very slow.
 
 
36-dates:
 
Update copyright dates.
 
 
36-news:
 
Final NEWS updates for the next release, including release date.

 
 
37-cleanup:
 
Miscellaneous fixes.

Fixed INSTALL doc file.

Fixes problem of variant field for fast ops not being big enough,
that disabled part of the static box optimizations.  Also cleaned
up unused fields.

Added a bit more use of static boxes (result of length, arg of
seq_len, conditions for if and while).

Moved some more error messages out of "eval" and related functions,
just in case this helps cache or other code aspects in time-critical
code.

Updates R-ints for current SEXPREC layout.

Tweaks to mods/README and INSTALL.

Fixed protect bug in promiseArgs.

Now pass 0-length vectors in .C or .Fortran as pointers to a block of
20 constant zero bytes, to accomodate/diagnose badly-written code.
 
 
37-new-news:
 
Added new NEWS section for the next release.
 
 
37-pkg-checks:
 
Modified tests/examples in the Matrix package to increase tolerance in
a test so it passes when long double is the same as double, and to
eliminate a test that fails when the time taken is supposedly too
long, which is not a portable criterion.
 
 
37-tests:
 
Add more tests of helper threads to tests/helpers.R, checking that
waits occur when they should.
 
 
38-nls-port-fix:
 
Fixes a bug in "nls" with algorithm="port".
 
 
39-parse-symbols:
 
Add a complete set of pre-installed symbols that are
used in the parser.
 
 
39-readBin-fix:
 
Fixes a bug in readBin, which showed up with gcc 4.9.2 on a SPARC system.
 
 
40-cleanup:
 
Miscellaneious small mods.

Make more error functions NORETURN.

Document hazards of UNPROTECT_PTR.

Clean up va_list declarations to no longer look like function calls.

 
 
40-deparse:
 
Changes deparse to look only at operator symbols, not bindings (which
are irrelevant).  

Fixes these bugs along the way:

  > deparse(parse(text="`+`(a,b)[1]")[[1]]) # Omits necessary parens
  [1] "a + b[1]"
  > a <- quote(f(1,2))                      # Omits necessary parens
  > a[[1]] <- function(x,y)x+y
  > deparse(a)
  [1] "function (x, y) " "x + y(1, 2)"
  > deparse(parse(text="a$'x'")[[1]])       # Doesn't distinguish name from char
  [1] "a$x"
  > deparse(parse(text="`$`(a,b+2)")[[1]])  # Result is not syntactically valid
  [1] "a$(b + 2)"
  > deparse(quote(`[<-`(x,1)),control="S_compatible")  # unmatched " and '
  [1] "\"[<-'(x, 1.)"
  > deparse(parse(text="`*`(2)")[[1]])      # Result is not syntactically valid
  [1] "*2"

Doesn't fix these bugs (yet):

  > deparse(parse(text="a = b <- c")[[1]])  # Puts in unnecessary parens
  [1] "a = (b <- c)"
  > deparse(parse(text="a+!b")[[1]])        # Puts in unnecessary parens
  [1] "a + (!b)"
  > deparse(quote(`+`(1,2) %fred% 4))       # Omits necessary parens
  [1] "1 + 2 %fred% 4"
  > deparse(parse(text="?lm")[[1]])         # Doesn't know about ? operator
  [1] "`?`(lm)"
  > deparse(parse(text="a:=b")[[1]])        # Doesn't know about := operator
  [1] "`:=`(a, b)"

There is also inconsistent behaviour with "if" seen below:

  > parse(text="{ .Call('fred',if (T) 3 else 4) }")[[1]]
  {
      .Call("fred", if (T) 3 else 4)
  }
  > parse(text="{ f('fred',if (T) 3 else 4) }")[[1]]
  {
      f("fred", if (T) 
          3
      else 4)
  }
  > parse(text="{ -(if (T) 3 else 4) }")[[1]]
  {
      -(if (T) 
          3
      else 4)
  }
  > parse(text="{ list(if (T) 3 else 4) }")[[1]]
  {
      list(if (T) 3 else 4)
  }

The behaviour of the above with these mods is in a state of flux...
 
 
40-fgetc:
 
Speed up reading a character at a time from files.

Fixes a bug in a check for malloc failing when allocting a buffer.
 
 
40-new-news:
 
Creates skeleton of new NEWS section for next release.
 
 
40-new-parse:
 
New parser implementation, using recursive descent rather than bottom-up
bison parser.  Accessible with "newparse", old one still used otherwise.

Removes parens from all expressions except those one right side of 
a formula (~).  This will need to change later to removing only necessary
parens.

Allows "else" on new line in expressions read from file (unlike old parse).

Bugs fixed here:

  > p <- parse()
  ?"abc;xyz"
  Error in parse() : 1:1: unexpected INCOMPLETE_STRING
  1: "abc;

  > p <- parse()
  ? 8 # dc;dd
  Error in parse() : 1:8: unexpected end of input
  1:  8 # dc;

Fixes incorrect and incomplete info in R-lang about operator precedence.
Makes some incidental fixes to copyright notices in the manual.
 
 
40-no-replDLL:
 
Eliminates the R_ReplDLLinit and R_replDLLd1 procedures in main.c,
and the calls of R_ReplDLL... in the front-ends/rtest.c program.
 
 
40-windows-fixes:
 
Some fixes to get pqR to build on Windows, using Rtools215.

Changes default type for install.packages to "source" for all
platforms.
 
 
41-parse-deparse:
 
Mods to the new parser and deparser.  The new parser now replaces the
old parser.

ReplIteration has been changed to no longer employ a horrible kludge
regarding semicolons, and otherwise be more sane.  Its interface is
different than previously.

The ->, ->>, and ** operators are now real operators.  This fixes the
following error reporting bug:

  > a + ** 2
  Error: unexpected '^' in "a + **"

Changes deparsing of complex numbers, so that the following no longer
happens:

  > deparse(quote(3*5i))
  [1] "3 * (0+5i)"

with the result instead being "3 * 5i".

Introduced the keep.parens option.

Now fixes these bugs mentioned in mods/40-deparse:

  > deparse(parse(text="a = b <- c")[[1]])  # Puts in unnecessary parens
  [1] "a = (b <- c)"
  > deparse(parse(text="a+!b")[[1]])        # Puts in unnecessary parens
  [1] "a + (!b)"
  > deparse(quote(`+`(1,2) %fred% 4))       # Omits necessary parens
  [1] "1 + 2 %fred% 4"
  > deparse(parse(text="?lm")[[1]])         # Doesn't know about ? operator
  [1] "`?`(lm)"
  > deparse(parse(text="a:=b")[[1]])        # Doesn't know about := operator
  [1] "`:=`(a, b)"

Corrected documentation on the = assignment operator.

Made %..% ops not deparse as ops if args have names (as in R Core
fix for PR15350).

Fixed the following bug (also in R-3.2.2):

  > a <- quote(if (x) X else Y)
  > a[[3]] <- quote(if (T) 3)
  > a
  if (x) if (T) 3 else Y                    # Omits necessary parens
 
 
42-helpers:
 
New version of helpers module with slight technical fix
and ability to ignore some calls before helpers_startup
called.
 
 
42-new-po:
 
Updates files regarding translations in the po sub-directory,
to account for changes in the set of source files.
 
 
43-later-R-Core:
 
Some fixes/mods from later R Core releases.
 
 
43-parse-data:
 
Mods from R-3.0.0 (up to R-3.2.2) regarding parse data, and related mods.

Allow srcfile arg to parse to be a filename, from R-3.0.0.
Fix error in help(parse) about srcfile non-NULL but a string.

Define getParseData and getParseText from R-3.0.0.
(No data to look at yet, though)

Fixed this bug (note that the 2 disappeared in the error report):

  > parse()
  ?'\12abc\x.'
  Error: '\x' used without hex digits in character string starting "'\1abc\x"

Fixed memory leaks in StringValue, eg, as below (but not if 820 changed to 810):

  > long <- paste0 (c('"', rep("1234567890",820), '\\x."'), collapse="")
  > for (i in 1:1000000) try (e <- parse(text=long), silent=TRUE)

Fixed off-by two in limit of 10000 characters in unicode string (limit
said to be 10000, but actually 9998).

Fixed bug in which caret for error report was misplaced.

Put working example in help(getParseData).

Fixed bugs with parens not being deparse in the following:

  e <- quote(f(x)); e[[2]] <- quote((a=1))[[2]]; deparse(e)
  e <- quote(f(Q=x)); e[[2]] <- quote((a=1))[[2]]; deparse(e)
  e <- quote(while(x) 1); e[[2]] <- quote((a=1))[[2]]; deparse(e)
  e <- quote(if(x) 1 else 2); e[[2]] <- quote((a=1))[[2]]; deparse(e)
  e <- quote(for(x in y) 1); e[[3]] <- quote((a=1))[[2]]; deparse(e)

 
 
43-startup:
 
Change how helpers are done in relation to startup of R - rather than
have helpers_startup called in mainloop, with helpers_master calling
setup_Rmainloop and then run_Rmainloop, have helpers_startup be called
inside run_Rmainloop.  This accommodates programs that don't call
mainloop, but call setup_Rmainloop and run_Rmainloop themselves.

Also restores the replDLL stuff for embedded applications, rewritten
for revised scheme in main.c.  Adds a test of this to tests/Embedding,
based on a rewriting of an example in R-exts.texi, which had several
errors.  Also, R_ReplDLLinit called SETJMP, which received a LONGJMP
after it had returned, which is definitely a no-no.  A better version
is implemented.  Changed rtest in gnuwin32/front-ends as well.

Changed the build process so that setting R_NO_BASE_COMPILE to FALSE
(as well as to an empty string or to nothing) means packages are byte
compiled.

Also makes more mods for Windows.  Changes how optimization levels are
set.  Introduced -mstackrealign when -msse2 is used to bypass problem
that gcc assumes greater alignment than Windows provides on startup.

Better documentation on Windows installation in gnuwin32/INSTALL,
with separate MkRules.dist32, MkRules.dist32-sse2, and MkRules.dist64.

Documentation changes as well, regarding embedding, Windows, etc.

Kludged helpers.c to bypass problem with omp.h in Rtools.

Fixed a problem in src/gnuwin32 with psignalc and psignal.h, where
"int" was used where "sigset_t" was needed.

Adds some fixes and other things for Windows from later R Core
versions.

Fixed ctrl-C problem only partially fixed by R Core.  In the 
process, split Rfe into Rfe (for R) and Rscriptfe (for RScript),
which is cleaner.

Add warning about OpenMP threads not having long double arithmetic.
 
 
44-cleanup:
 
Miscellaneous cleanup.

Update R-ints.texi about primitives.

Make -> and ->> not be counted as undocumented primitives in QC.R.

Fix failure to try harder when no free nodes but could collect
older generations.
 
 
44-copyright:
 
Update copyright notices for recent mods.
 
 
44-news-rel:
 
More updates to NEWS.Rd
 
 
44-xlen:
 
Add compatibility stubs for R_xlen_t, XLENGTH, etc.
 
 
45-update-po:
 
Ran "make update-po" in a build directory to update the po directory.
 
 
46-along:
 
Implement the "along" version of "for".
 
 
46-dotdot:
 
Implement the .. operator, as a better version of :

Also fix bug where 0x1.2.3 gave no error, and bug where "i" and "L"
didn't end up in parse data in "1i" and "1L".

Allow real constants like 0x1.8 (equal to 1.5), which are inexplicably
disallowed in R Core versions.  (Previously allowed but with . ignored
in pqR.)  Also allow this for input from 'scan', etc.  Updated 
NumericConstants.Rd, incorporating mods from R-3.3.0 version.

Updates R-lang.texi and several help files to document .. (and fix a
few other things).

Introduce parse_dotdot option, defaulting to TRUE, but which can
be overridden with R_PARSE_DOTDOT environment variable.

Change how make.names works, so it meshes with not allowing .. in middle.

Make "unique" not append a separator when the name already ends with it.
This avoids creation of invalid names with parse_dotdot is TRUE.

Now deparse according to parse_dotdot as well.
 
 
46-drop-dim:
 
Implement suppression of dimension dropping when
a numeric subscript has a 1D dim attribute.

Fixed bug illustrated by 

  b <- array(c(3),dimnames=list(xyz=c("fred")))
  attr(b,"fred") <- 1
  print(b[1])
  print(b[])  # should print same thing

Except as special kludge to keep packages working, have
b[,drop=FALSE] return a duplicate of b, as before (keeping
dimensions and attribues).

Fixed bug (also fixed in R Core) illustrated by

  a <- array(c(3,4),dimnames=list(xyz=c("fred","bert")))
  print(a[1:2])
  print(a[])  # should print same thing
 
 
46-fixes:
 
Miscellaneous fixes.

Fix to methods_list_dispatch.c that caused make check-all failure
in no-segfault test on Windows 10 (pqR issue #29 + related fix).

Fixed bug illustrated by 

     atan; show<-function(x)cat("HI\n"); atan

Put in check for non-existent primitives when unserializing, from R-3.0.1.

Fixed problem with identifying makeinfo version in later versions.

Fixed problems in do_set that led to unnecessary waiting for computations 
to finish.

Fixed problem with pqR sometimes hanging when helpers_trace enabled and
then output is interrupted.  Now uses REprintf for helpers_printf rather
than Rprintf, which seems to not check for user interrupts.

Also changed R_CheckUserInterrupt to not do R_CHECKSTACK if interrupts
are supposed to be suspended.

Finally, got rid of get_rm in nrow, etc., since doesn't at present help.
 
 
46-version-doc:
 
Update version to 2016, fix texi problems in documentation files.
 
 
47-missing-under:
 
Implements '_' as an explicit missing value, and its
use to signal that a diminsion should not be dropped
with '[ ]'.


Fixed the following bug (also in R-3.3.0):

  > f <- function (...) ..2
  > f(1,,2)

  > g <- function (a,b,c) b
  > g(1,,2)
  Error in g(1, , 2) : argument "b" is missing, with no default

Call of f should also produce an error.  But this bug fix has been
reverted, because it leads to make check failing (problem with NextMethod).


Fixed the following bug (also in R-3.3.0):

  > f <- function (...) ..1; f()
  Error in f() : 'nthcdr' needs a list to CDR down

The error is now "Error in f() : The ... list does not contain 1 elements".


Fixed the following bug (also in R-3.3.0):

  f <- function (x) { try(x); missing(x) }
  g <- function (y) f(y)
  h <- function (z) g(z)

  f(pi[1,1])  # FALSE
  g(pi[1,1])  # FALSE
  h(pi[1,1])  # TRUE - but shouldn't be!


Now no longer use PRSEEN in R_isMissing (needed to fix bug above, and 
to do missing_from_underline properly).


Added tests of missing and missing_from_underline to eval-etc.R.


Fixed description of x[] in R-lang.texi, which was correct for neither
R Core nor the new pqR semantics.
 
 
47-new-matprod:
 
New version of matprod module.  Differences are only cosmetic tweaks.
 
 
48-copyright:
 
Some updates to copyright notices/dates.
 
 
48-dataframe:
 
Mods to data frame code to take advantage of .. and _.

Also improves tests in simple-true.R.  (Many tests would often appear
to be OK even though the result was wrong.)

 
 
49-news:
 
NEWS.Rd for new release.  Also tweaks to mods/README.

 
 
49-no-byte-compile:
 
Eliminate the option of byte compiling the base package, since the
compiler won't work with some new features such as "along" and "_",
which are used in the base package.

 
 
49-update-po:
 
Ran "make update-po" in the 'po' subdirectory of a build directory to
update the po directory.
 
 
49-windows:
 
Update instructions for Windows installation.
 
 
50-digest:
 
Make "digest" a recommended package, and modify it and 'serialize' as
needed to make it work with pqR, adding the nosharing argument (also
added to saveRDS).


 
 
50-fixes:
 
Miscellaneous fixes.

Corrects incorrect link to blog posts.

Change INSTALL for windows to reference only Rtools33 at pqR-project.

Update index.html for html info, including windows version of it.

Corrected incorrect information in R-exts that said pairlists are not
user visible in R.

Changed default for last in substring to .Machine$integer.max

Corrected wrong information about length of expressions in help(length).
 
 
50-for:
 
Add "across" and "down" versions of "for".
 
 
50-from-2.15.1:
 
Changes taken from R-2.15.1.

Put in the (minor) changes in the "grid" package from 2.15.1, except
for the Polish translations.

Fix for is.unsorted from 2.15.1, in base/R/sort.R, NEWS from 2.15.1 is:

      is.unsorted() gave incorrect results on non-atomic objects such
      as data frames.  (Reported by Matthew Dowle.)

Took entire splines package from 2.15.1.  This includes new feature
described in 2.15.1 NEWS as

      splineDesign() and spline.des() in package splines have a new
      option sparse which can be used for efficient construction of a
      sparse B-spline design matrix (_via_ Matrix).

Made change from 2.15.1 described in NEWS as follows:

      source() now uses withVisible() rather than
      .Internal(eval.with.vis).  This sometimes alters tracebacks
      slightly.

Small fix to tcltk/src/tcltk.c from 2.15.1.

Changes to parallel to incorporate mods from 2.15.1, including those 
corresponding to these NEWS entries:

      In package parallel, makeForkCluster() and the multicore-based
      functions use native byte-order for serialization 

      In package parallel, clusterApply() and similar failed to handle
      a (pretty pointless) length-1 argument. (PR#14898)

Performance improvement from R-2.15.1 with NEWS as follows:

      tabulate() makes use of .C(DUP = FALSE) and hence does not copy
      bin.  (Suggested by Tim Hesterberg.)  It also avoids making a
      copy of a factor argument bin.

All of 'graphics' package taken from 2.15.1, which does the following
from 2.15.1 NEWS file:

      The plot() and Axis() methods for class "table" now respect
      graphical parameters such as cex.axis.  (Reported by Martin
      Becker.)

      In legend(), setting some entries of lwd to NA was inconsistent
      (depending on the graphics device) in whether it would suppress
      those lines; now it consistently does so.  (PR#14926)

Took entire stats4 package from 2.15.1, but only change is adding
Polish translations.

Check of argument length in seq (already done for seq.int), described
in 2.15.1 NEWS as

      Nonsense uses such as seq(1:50, by = 5) (from package plotrix)
      and seq.int(1:50, by = 5) are now errors.

Fix of mkChar and mkCharCE from 2.15.1, described as

      C entry points mkChar and mkCharCE now check that the length of
      the string they are passed does not exceed 2^31-1 bytes: they
      used to overflow with unpredictable consequences.

Took base/R/merge.R and base/man/merge.Rd from R-3.1.1, except deleted
large vector stuff.  Updated tests in reg-tests-1b.R and .save.
Implements bug fix from 2.15.1:
      More cases in which merge() could create a data frame with
      duplicate column names now give warnings.  Cases where names
      specified in by match multiple columns are errors.
And new feature from 3.0.0:
      merge() works in more cases where the data frames include
      matrices.  (Wish of PR#14974.)

Took base/R/kappa.r from R-2.15.1, which has implementation of matrix
2-norm mentioned in 2.15.1 NEWS.

Merged in all of stats package.

Updated 'by' in base.

Updated VERSION to 2.15.1 (used for package compatibility checks).

Updated src/main with various mostly minor things from 2.15.1
 
 
50-new-protect:
 
Implement, document, and use a new scheme for protection of pointers.
 
 
51-news:
 
Start of NEWS file for next release.

Also, removes "future directions" part of R-ints (better documented elsewhere).

 
 
51-recommended-pkgs:
 
Updates to use versions of recommended packages used in 2.15.1:

Changes are to use the following:

   MASS_7.3-18, mgcv_1.7-18, nlme_3.1.104, rpart_3.1-53, survival_2.36-14

mgcv is again tweaked to not force byte compilation

Did not update to new versions of Matrix and foreign, which were
modified for pqR to fix bugs, and had no substantive updates in the
versions for 2.15.1.
 
 
51-safeguard-call:
 
Adds defensive measures against argument abuse in .Call and .External,
by automatically duplicating and re-assigning the values of variables
that are atomic scalars with no attributes if they have NAMEDCNT > 1.

Also re-organizes stuff in dotcode.c, and handling of builtins in
eval.  .C, .Fortran, .Call, and .External are now "specials", and
evaluate their own arguments, and create their own contexts.

Somewhat motivated by the above changes, the 'methods' package now
uses new .Internals called get_slot.internal and set_slot.internal.
 
 
52-opt:
 
Performance optimization / tuning.  (Also, a bit of general cleanup of
comments, etc., and one extension.)


Got rid of saving of R_EvalDepth in eval, in favour of increment/decrement.
It's saved and restored in/from contexts anyway.

Put a selection of global variables that are frequently used into a
structure to ensure reference locality (and possibly allow the
compiler to address faster).

Eliminate save/restore of R_Srcref in eval, do when modified elsewhere
instead.  It's already saved in contexts for restoration on longjump.

Introduced R_EVAL_TWEAKS, which may be defined by a compiler argument,
to control which tweaks concerning eval are enabled.

Now allow R_CStackDir to be a constant, defined by a compiler
argument, rather than determined at run-time initialization.  Now
assume downwards growth, though this can be overridden.  Code for
run-time check has been kept, but is currently never used.

Changed how R_Visible is handled, updating R-ints.texi to explain new
scheme.  This change reduces overhead in eval.


For merge reasons, this branch also implements a change to allow things
like "a"[3] <- 2, for consistency with "a" <- 2 being allowed.
 
 
52-subassign:
 
Speed up simple scalar assignments with [<- when index is a positive
number, replacement is a scalar, and types match.

Slight improvements to [<- and $<- from looking for evaluated promises.
 
 
52-tests:
 
Update to tests to avoid spurious differences.
 
 
52-var-unclass-attr:
 
Implements a variant result (from VARIANT_UNCLASS) in which a class
attribute can still be present even though not supposed to be there
(eg, from unclass).  

Also a variant result (VARIANT_ANY_ATTR) in which any attributes may
(or may not) be returned, because their presence or absence will be
ignored by the caller anyway.  And a variant result (VARIANT_ANY_ATTR_EX_DIM)
like this excep that the dim attriute must be correct.

Use these in do_for, do_sum, do_prod, and do_length, do_subset3, do_arith,
and do_relop.

Pay attention to VARIANT_UNCLASS in unclass.

Pay attention to VARIANT_ANY_ATTR and VARIANT_ANY_ATTR_EX_DIM in math1.

Pay attention to VARIANT_ANY_ATTR in do_arith.

Added tests for this to assignperf.R
 
 
53-more-news:
 
Yet more NEWS updates, as needed for next release.
 
 
53-static-boxes:
 
Macros for cleaner scheme to save/restore static boxes.
 
 
53-subassign:
 
Implement fast interface for primitive subassign functions.

Also introduces R_NoObject.

Correct information in help([[) ([[<- can have multtiple indexes).

 
 
54-final-fixes:
 
Some final fixes for release compatible with 2.15.1.

Fixed bug introduced in 2.15.1 with utf8toucs returning size_t but
indicating error by negative value.  Fixed some similar problems with
mbcstowc, but the problem is pervasive in the character coding
routines, and partly originates in external libraries.

Fixed problems with missing argument introduced in pqR-2016-06-24.
For instance 

   f <- function (x) x;  g <- function (y) f(y);  g()

failed to give an error.  Added more tests.

Also, fixed lack of error from

   f <- function (x) { names(x) <- c("a","b"); x }; f()

Fixed problem with complex arithmetic, illustrated by

   a <- 1:10; b <- (1:10)+0i; a-b

The fix also speeds up arithmetic with mixed complex and real/integer
operands.

Fixed help on ** operator.
 
 
54-subassign:
 
Change fast interface to subassignment to allow rhs to be evaluated in
a static box.  (Note that it must not be kept in a static box if the
assignment ends up putting it in a list.)

Slight speed tweaks involving get1index.
 
 
55-build:
 
Mods to fix mac build problems on El Capitan and Sierra.

Revises Rscript makefile entry.

Compiles aqua on mac with default mac gcc.
 
 
55-fixes:
 
Fixes involving interaction of active bindings and finalizers with pqR
optimizations.

Also fixes instances of LCONS(fn,LCONS(arg...)), in which second LCONS
should be CONS.
 
 
56-news:
 
NEWS for the next small maintenance release.
 
 
57-new-gc:
 
Replaces the previously-used garbage collector with one using sggc.

Information about this is in NEWS, R-admin, R-exts, and R-ints.

Got rid of --enable-strict-barrier, which is not needed in pqR to make
CAR(x)=y illegal.  The PROTECTCHECK aspect of it may be reintroduced
later.

Also fixes the problem of manual cross-references going to wrong
versons at r-project.org (noted in NEWS).

Changed how hashing for symbols works, may be desirable to
change suppression of serialization of gp bit 1...

Fixed following bug (crash), arising from "identify" was returning C NULL
sometimes - changed to R NULL:

a<-.Internal(identify(numeric(0),numeric(0),character(1),1,TRUE,0.5,0.25,FALSE))
 
 
58-fixes:
 
Miscellaneous fixes.

Added xlength and xlengthgets functions for compatibility with R >= 3.

Minor fixes (some possibly real) to avoid gcc7 warnings.

Changes to "identical" to treat TAG as equal/not-equal without
reference to PRINTNAME, also avoids taking PRINTNAME of R_NilValue.

 
 
58-gc-level:
 
Adds a "level" argument to "gc", which specifies the level of collection
to be done.
 
 
58-globals:
 
Replace global hash table of symbol bindings with use of attrib field
in symbols for global binding (along with value field for base bindings).


This requires (silently) disallowing setting of attributes on symbols
at R level, which are not currently saved in a workspace in any case.
This is documented in NEWS, help(attr), and help(attributes).

New ATTRIB_W macro for internal use allows r/w access without such
checks, as needed for use for global bindings, or for efficiency.

 
 
58-no-old-save:
 
Get rid of old save/load code for obsolete formats, since it would
need to be modified when env hash scheme is changed.
 
 
58-symtbl:
 
Change symbol table to use lphash library.  Allows removal of the next
link from symbol objects, making space for symbits.
 
 
58-tests:
 
More tests.  

tests/extend-contract.R tests vector extension and contractions with
length<-, [, [[, and $.
 
 
59-hash-env:
 
Changes regarding hashed environments.

Minimum size of hash table now depends on pointer size/type.  Now
expands by factors of two.

Default env size is now NA (internal default).

Hash for environemnts in SYM_HASH(symbol) is now taken from CHAR_HASH
of printname.  CHAR_HASH/SYM_HASH now only 31 bits, so signed/unsigned
not an issue.

Serialization converts to old hash scheme on write, and to the new
hash scheme on read, for backcompatibility both ways.

 
 
59-relop:
 
Optimize relational operators on strings to avoid % for ==/!=.

Implement and/or/sum variants for relational operations on all types.

Structure as task procedures (except for strings), and do in helpers
for non-variant and sum variants.
 
 
59-symbits:
 
Replace the special flag for symbols like +, -, etc. by a more general
method of quickly determining that some symbols do not have a binding
in an environment.  Removes the "last symbol not found" facility,
which should be largely superceded by this change.

Fixed bug: a <- as.integer(NA); e <- new.env(size=a); print(a)
 
 
60-matprod:
 
New version of matprod, that uses "restrict" to allow better optimization.
 
 
60-new-lphash:
 
New version of lphash, and changes to use it.

PRINTNAME now kept in symbol table hash bucket.

 
 
61-expand:
 
Improve performance when vectors are extended/contracted.

Done for length(vec) <- len.  Also now allow length(e) <- len when e
is an "expression".  Fix length(p) <- len when p is a pairlist/language object.

Done for [, [[, and $ as well.

Introduces new internal procedures getNamesAttrib and no_dim_attributes.
 
 
61-more-symbits:
 
Puts back the lastsymenvnotfound feature, since symbits don't
replace it entirely due to environemnts with too many symbols.

Puts printname back in symbol (not symbol table hash entry), as 
not having it there slowed some operations.

Also uses symbits for more environments, including hashed ones.
 
 
62-all-cached:
 
Changes based on all CHARSXPs now being cached (except NA_STRING),
so some simplifications/speedups are possible.
 
 
62-collate:
 
Put in some collation stuff from later R Core releases, both for
features, and for performance improvement.

Includes putting ICU in "capabilities()", the new icuGetCollate function,
and changes to icuSetCollate.

Also improvement to looping in string_relop, and stash pointer to
improve performance with compressed pointers.

 
 
62-fixes:
 
Fixed documentation of non-existent arguments to debug and debugonce.

Fixed a bug in [[<- for environments.

Fix GC strategy to check regularly, avoiding constant expansion of
memory.
 
 
62-misc-perf:
 
Miscellaeous performance improvements.

Removed a call of R_data_class in R_set_class, because its value
is never used.

Do %% and %/% on real operands that are integers same as for integer 
operands.

Speed up "which" a bit by tweaking the R code.

Use memcpy in DUPLICATE_ATOMIC_VECTOR.
 
 
62-no-byte-compile:
 
Change the defaults to not byte compile packages, even if asked to in
DESCRIPTION or otherwise, and to ignore byte code when evaluating a
function.  

Thse changes can be overridden only by setting the R_PKG_BYTECOMPILE
and R_USE_BYTECODE environment variables to TRUE.

JIT is now never enabled.
 
 
62-rep:
 
Performance improvement to rep.

Added rep_len as in R-3.0.0.  Took the outer code for it largely from
R-3.4.0, with actual operation done in a pqR task procedure.
 
 
62-strict-ieee:
 
Require that doubles obey strictly-correct IEEE 64-bit floating point.

This eliminates use of x86 FPU, hence only SSE2 allowed.
 
 
63-scalar-stack:
 
Switch from using static boxes to using a scalar stack. 

Also makes general improvements to do_subset and do_subset2, 
including avoiding copy in unclass(obj)[1] or unclass(obj)[[1]].

 
 
63-sym-dots:
 
Speed up check in eval for ..., ..1, ..2, etc., by dedicating
a bit in sxpinfo to flagging symbols that are not ..., ..1, etc.

Also, defines and uses SET_NAMEDCNT_NOT_0 to set to 1 if 0 without
waiting to not be used by helpers.

Uses EVALV more sparingly.
 
 
64-arithmetic.c:
 
Improve arithmetic performance.  Allows fast operations on
mixed integer/real scalars.
 
 
64-doc-news:
 
Updates to R-ints.texi to account for miscellaneous recent changes.

Also updates NEWS.Rd.
 
 
64-dotcode:
 
Cleanup and performance improvements in dotcode.c.  Also minor
feature changes regarding errors/warnings.

Also defines inherits_CHAR.  Preallocates "factor", "ordered", and
"NativeSymbolInfo", and uses them with inherits_CHAR in many places.

Makes eval_unshared in eval.c non-static.
 
 
64-paste:
 
Performance improvements to paste/paste0.

Speed up by changing .Internal interface, avoiding list(...), and
internally by having an array of string vectors rather than a
pairlist, plus not concatenating single things, and avoiding a big
buffer for collapse.

Created Rf_mkCharMulti to support paste.  Also used it to speed up
substr and substr<- a bit.
 
 
64-subassign:
 
Improvements to subassignment operators.

Added array_sub inline function for faster handling of scalar
subscripts.  Also used in subset.c.

 
 
65-S3:
 
Improvements to S3 method handling.

Also a tweak to unclass.

 
 
65-S4:
 
Improvements to S4 class operations.

Defined .el.methods as a primitive, used for el in methods package.

Takes new version of @<- as a primitive from R-3.0.0.
 
 
65-new-lphash:
 
Use new versoin of lphash that allows for multiple static versions
(but not used yet).
 
 
65-seq-for:
 
Improvements to VARIANT_SEQ interface and to for loops.
 
 
65-sub:
 
Tweaks to subscipt handling.  Also creates inline functions for
getting certain attrihutes.
 
 
66-c:
 
Sometimes avoid allocation in 'c' by expanding space used by 
first argument.  Does this for both c(v+1,x) and v<-c(v,x).

Sometimes does copying for 'c' in a helper thread.
 
 
66-class:
 
Use getClassAttrib.
 
 
66-coerce:
 
Unrolls loops in copy_elements_coerced.
 
 
66-match:
 
Improvements to match, %in%, etc.  Taken/inspired by mod in R-3.3.0.
 
 
66-subassign:
 
More speed improvements to [<- and [[<-.
 
 
66-subset:
 
More performance improvements in subset.

Also, feature change regarging names on scalar results.
 
 
67-classes:
 
Performance improvements to S3 and S4 classes.

Fiddles R def of slot<- and @<-.

Speeds up R_data_class and R_data_class2 using pre-allocated CHARSXPs.

Also, some more use of getNamesAttrb and getDimAttrib.

 
 
67-math:
 
Performance and features changes involving math.

Changes to 'cumsum', affecting both performance and behaviour.
Also changes to 'cumprod', affecting behaviour with complex vectors.
Other more minor changes to other parts of cum.c.

Change to 'prod' for complex vectors.
 
 
67-sample:
 
speed up sampling without replacement with 'sample'.  Uses a hash table
sometimes, but in such a way as to produce the exact same results as
the non-hash method.
 
 
67-subscript:
 
Improvements in subscript.c.

Speeds up subscripting with a logical vector, with alternative
implementations for 32/64-bit platforms.  

Improvement for negative subscripts to allocate flags as bytes
rather than as ints (saving memory).


 
 
67-which:
 
Speed improvements to 'which' - loop unrolling, use of local array,
and of reallocVector - two implementations for 32/64-bit platforms.

 
 
67-which-min:
 
Speed improvements to which.min and which.max, based on R-3.2.3, with
additional improvements added.
 
 
67-whole-body:
 
Introduce VARIANT_WHOLE_BODY, and use for .Internal to sometimes avoid 
incrementing NAMEDCNT for args.
 
 
68-c-unlist:
 
Speed improvements to c and unlist.

Also improves speed of copy_elements using memmove.

 
 
68-general:
 
Various mods involving eval and other aspects of performance.

Alternative scheme for type flags, selectable.

Tweaks in arithmetic.c.

Fixes some places where VARIANT_PENDING_OK wasn't being used when
it should have been (and used to be).

Special handling of 0 or 1 arguments in evalList_v, promiseArgs,
and promiseArgsTwo.

Special handling of 0, 1, or 2 positional arguments in matchArgs.

Tweaks to pmin and pmax.

Tweaks to match.arg.
 
 
68-lengths:
 
Add 'lengths' function from R Core releases.
 
 
68-unary:
 
Change unary +, -, ! to match new behaviour in R-3.1.0.  Also
improves performance of ! by sometimes reusing storage.
 
 
69-logic:
 
Speed up logical operators (!, &, |). 

 
 
69-matrix-array:
 
Speed up 'matrix' and 'array'.  Defines better copy functions.

Fixes a bug in 'matrix'.
 
 
69-read:
 
Performance tweaks to readLines and scan.
 
 
69-sort:
 
Updates to 'sort', 'order', 'rank', and related functions.

Adds the new radixsort internal from later R Core versions.

Adds a newly-written merge sort.

Tweaks other aspects for performance.
 
 
70-collation:
 
Changes SCollate to handle vmax itself, and to consistently call
'error' on error, rather than set errno.  Changed sort.c and relop.c
to match.

Also tweaks translateChar.
 
 
70-numeric:
 
Update to numerical routines.

Tweaks to copy_transpose.
 
 
70-paste:
 
More improvements to 'paste', especially speeding up
pasting with integer vectors.
 
 
70-pending:
 
Do more in helper threads - &, |, !.  Plus some cleanup.
 
 
70-set-subassign:
 
Revisions to set_subassign in eval.c, to make it faster by using the
fast interface for the outermost level of a complex assignment (not
just for simple assignments).

Also tightens up some things involving NAMEDCNT that might perhaps
cause bugs.  And fixes a performance bug.

 
 
71-features:
 
Various features from R Core releases.

Added trimws from R-3.2.0, modified to slightly improve performance.

Added strrep from R-3.3.0, modified to substantially improve performance,
and use it in a few places as in later R Core versions.
 
 
71-from-R-3.4.2:
 
Some fixes / improvements from R-3.4.2.

Bug fix in radixsort.c
 
 
71-perf-tweaks:
 
Various performance tweaks.

Used saved data pointers in several routines - may help with compressed
pointers.

Improved any/all loops.

Improved subassign operations, especially with [[ and $, using VARIANT_FAST_SUB.
Also improved interfact to subscript.c, avoiding some NaN checks.

Put in special AVX code for some operations, used when AVX available,
which can be disabled by defining DISABLE_AVX_CODE.

Revised ISNAN checks.

Improved logicalSubscript for recycling cases.
 
 
71-realloc-mod:
 
Change interface to reallocVector to allow caller to suppress copy to
new storage (sometimes more efficient for caller to do it).  This new
facility is not used yet.
 
 
71-str-num:
 
Performance improvements to conversions from strings to
integers/doubles/logicals and vice versa.

Also fixed bugs in which as.numeric("0x1.1.1p0") didn't give an error,
as.numeric("0x1fffffffffffff.7ffp0") gave an incorrectly-rounded result.

And fixed bug illustrated by print(c(F,NA,NA,F),na.print="abcdef")
 
 
71-unlist-names:
 
Modify how names are added in unlist and c.  Addresses a performance
issue also addressed in R-3.4.2, but with a rewrite of the code that
also improves it in other respects (both performance and cleanliness).

 
 
72-S3:
 
Improvements to S3 dispatch, some from later R Core versions.
 
 
72-new-sggc:
 
New version of SGGC.
 
 
72-regexp:
 
Speed improvements to grep, grepl, sub, and gsub.

Includes tweaks replacing length with LENGTH as in R-3.3.0.

 
 
72-tweaks:
 
Fairly minor tweaks.

Made ep_match_strings an inline function, with special check for
identical string pointers.


 
 
73-align:
 
Establish alignment of numeric vectors, which can also be declared
when using gcc (or gcc look-alike), for possibly-better code generation. 
 
 
73-fixes:
 
Miscellaneous fixes, including to simple_concatenate.

 
 
73-helpers:
 
New version of helpers module with fix for wrong lock structure size,
new helpers_debug facility, and other minor changes.
 
 
73-tests:
 
Added the vec-alloc test.

Also corrected documentation on showConnections and getConnection,
and changed examples, eliminating an example that (correctly) failed
when gctorture was enabled.

 
 
74-envir:
 
Some cleanup and performance tweaks in envir.c.  Moves some info in comments
in envir.c to R-ints.texi.

 
 
74-matprod:
 
Changes to use a new version of the matprod library, that allows for
parallelizing operations, and with substantial other performance
improvements, as well as API changes.

Also includes a new version of SGGC, which records more info of use
for debugging (and other uses).  Other refinements to debugging
facilities are also made.

 
 
74-mv-bcode:
 
Moves bytecode stuff from eval.c into a new bytecode.c source file.
Removes some now-disabled JIT stuff.
 
 
74-no-applydefine:
 
Get rid of the old defunct / disabled "applydefine" code in eval.c that is
superceded by the new scheme for subsetted assignment.
 
 
75-move-code:
 
Code movement.  May have performance impact, not just cosmetic, since
compiler can optimize calls within a file.

Move all code from logic.c into eval.c (deleting logic.c).
Move do_relop from relop.c into eval.c (R_relop stays in relop.c).

Move do_arith from arithemtic.c to eval.c, with some other mods, 
including removal of "probable complete loss of accuracy in modulus"
warning from myfmod.

Move some code out of eval.c to builtin.c.

Other cosmetic changes. 
 
76-eval:
 
Revise how the "evalv" function is written, along with the "EVALV"
macro, to reduce overheads and maybe make branch prediction work
better.

New SETCAR_NIL, etc. and SETCAR_MACRO, etc.  Also revised SET_TAG.

Improve performance of && and ||.

Improve numeric scalar performance of relational ops, use VARIANT_ANY_ATTR
there and in "if" and "while".

Other performance improvements too.

Also fixes bug illustrated by f <- function (...) ..1(2); f(sqrt),
which previously produced an error rather than the square root of 2.

 
 
76-misc:
 
Miscellaneous mods - eg, to avoid compiler warnings.

Got rid of R_get_arith_function.

Got rid of alternative way of doing type sets.

Created attribute_noinline for later use.
 
 
77-sxpinfo:
 
Modify sxpinfo structure, primarily to allow fetching of type,
pending, non-scalar, and has-attribute bits as a single byte, for
quickly checking all of these.  Eval and other things changed to
exploit this.

Fix things so that NA_LOGICAL and NA_INTEGER are constants in
the inlined functions of Rinlinedfuns.h.

Also at one point (still in the git history) eliminated setting of
attributes on primitive functions, but after second thoughts this has
been reverted (maybe should instead make this actually work properly,
with duplicate making a copy of a primitive object).
 
 
78-lookup:
 
Improvements to variable lookup.

Sets LASTSYMENV for a newly-created argument, unless it is missing.

Also sets LASTSYMENV when a new variable is created in an unhashed environment.
 
 
78-visible:
 
Fiddle with how R_visible is set. 

Also removes redundant stack balance and vmax checks in do_internal.

 
 
79-arith:
 
Improvements to arithmetic.

Better versions of mod_iterate, used for arithmetic / comparison / etc.

Revisions to merged operations, doing only basic ops and abs, not other
math1 functions.

 
 
79-connections:
 
Improvements to readLines, scan, etc.

Makes dummy_fgetc faster by making it smaller, by preventing inlining into it.
Other inline and other performance fiddles.

Use the 25-byte buffer formerly used only for conversion as a performance
aid as well, replacing getc with read.

Also speeds up output formatting by avoiding log in IndexWidth.

Makes seek return NA for re-encoded connections.
 
 
79-eval2:
 
More performance tweaks to eval.
 
 
79-fixes:
 
Bug fixes.

Fixed bug with format(3.1,width=9999), etc.
 
 
79-isnan:
 
Speed up is.nan.

Uses new ISNAN_value patterned on glibc's isnan.
 
 
80-load:
 
Improvements to package loading, other startup time issues, which
have veered off into distantly-related changes.

Increased initial symbol hash table size from 8K to 16K.

Got rid of occurrences of 29L w.r.t. hash table sizes.

Also introduces minlength argument for memory.profile

Includes attempts at not always duplicating attributes when assigning
them, rather conservative, in hopes that this may reduce duplication
of things like scalar strings at startup, and also for class
attributes.

Applys the usual kludge to get @<- to not increment NAMEDCNT.

 
 
80-perf:
 
Miscellaneous performance and other improvements.

Various mods to eval and core operators such as subset and subassign.

Defines and uses Rf_set_elements_to_NA.

Speeds up any and all.

Speeds up min and max for reals.

Expands scalar stack.

Speeds up nchar.

Other stuff.
 
 
81-helpers:
 
New version of the 'helpers' module, that supports the "hold" facility.
 
 
81-names:
 
Changes to allow names to be updated without copying.

Implements VARIANT_QUERY_UNSHARED_SUBSET for names(x).

Doesn't always set NAMEDCNT to MAX for names.

 
 
81-ref:
 
Add defs for R Core macros like MAYBE_REFERENCED, for compatibiltiy.
 
 
82-arith:
 
Changes regarding arithmetic.

Convert x/2 to 0.5*x even when x is integer.

Revised merging scheme to only merge div as last op, and reduce size
of code from switches.

Use the new "holding" facility of the helpers module for mergeable tasks.

 
 
82-digest:
 
Use new version of digest package.
 
 
82-features:
 
Added features from R Core releases.

Adds provideDimnames from R-3.0.0, as the same R function
as in R-3.5.0.

Adds assertCondition, etc. from R-3.0.2.

Added anyNA, defined as any(is.na(x)).

Added chkDots from R-3.3.0; use in seq.R, lm.R, and density.R.

Added startsWith and endsWith from R-3.3.0.

Added bytes arg to Rprofmemt.
 
 
82-fixes:
 
Bug fixes.

Adds wait for arg being computed to dup_to_level.

Fixes some setup bugs in const-objs.c

Fixed bug in PROTECT, regarding timing of increment of Top.

 
 
82-par:
 
Work on doing things in parallel.

Refines how c(...) works for parallel operation and realloc.

Allows math1 functions to be done in two threads.

 
 
82-release:
 
Changes to NEWS, etc. to create a preliminary test release.
 
 
82-special-variant:
 
Make all SPECIAL primitives take a 'variant' argument, so that
this doesn't have to be checked for in evalv_other.

Also now uses VARIANT_RETURN_DIRECT for returns inside loops.
 
 
83-fixes:
 
Fixes to pqR-2017-07-05 to make revised release.

Fixes bugs with not popping scalar stack values.

Fixed bug with LASTSYMENV and active bindings.

Made "names" legal as a slot for an S4 object, but not if
it's also a vector and the values isn't a character string.

Fixed startsWith to allow NULL arguments.
 
 
83-install:
 
Changes to fix installation problems, especially for Windows.

 
 
83-perf:
 
Minor performance tweaks for revised release.
 
 
84-boot:
 
Use version 1.3-9 of recommended 'boot' package, tweaked for pqR
and renamed versions 1.3-9-1.
 
 
84-deparse:
 
Bug fixes and cleanup in deparse.c.

Bugs reported by Martin binder on r-devel, 7 July 2017.

 
 
84-digest:
 
New version of "digest" recommended package, with R "Depends"
changed for pqR.
 
 
84-eval:
 
Ensure that evaluated arguments are not changed by evaluation
of later arguments.  Adds tests for this.  

Other performance improvements too, including introduction of
install_translated, and faster subassign for simple cases.



 
 
84-helpers:
 
New helpers version with changed regarding HELPERS_MAX_TASKS and
HELPERS_MAX settable by application.
 
 
84-malloc:
 
Changes to how dlmalloc is used.  Fixes problem with Windows version.
Can now use dlmalloc for non-Windows builds too, if -DLEA_MALLOC used.
 
 
84-mods:
 
Miscellaneous mods before revised release.

Added minimal "slots" arg to setClass.

Improved efficiency of serialize/unserialize, eliminating use
of Sun's XDR routines.

Improvements to "sort", etc.

Fiddles with matchArgs.

Tweaks to NAMEDCNT macros.

Improvements to :: and :::.

 
 
84-seek:
 
Get seek to work for file connections with encoding.
 
 
84-substitute:
 
Speed up substitute.
 
 
84-tests:
 
Update saved test output.
 
 
84-update-po:
 
Editted POTFILES.in, then ran "make update-po" and "make update-pkg-po"
 
 
85-distance:
 
Changes to stats::dist.

Changes canberra distance definition, as in R-3.5.1.

Improves performance.
 
 
85-fixes:
 
Miscellaneous bug fixes.
 
 
85-get:
 
Mods to get and mget, adding get0.
 
 
85-options:
 
Speed up 'options', more so for setting than getting.
 
 
85-parse:
 
Modifications to parser to fix the problem of outer-level "else" being
rejected when sourcing a file (or parsing from file or text variable, or
in Rscript).  Also --peek-for-else option to control this in other 
contexts.

Other parsing cleanup as well.  Also slight performance tweak to getOptions.
 
 
85-sggc:
 
New sggc with bug fix.
 
 
85-tests:
 
Test improvements, especially for matprod.
 
 
85-undef:
 
Minor mods/fixes motivated by problems identified with -fsanitize=undefined.
 
 
86-Rscript:
 
Changes to Rscript from R-3.5.0
 
 
86-packages:
 
Updates to recommended packages.
 
 
86-parseops:
 
Implements the new binary operators !! and ! as concise ways of
calling paste and paste0.
 
 
87-forceSymbols:
 
Add R_forceSymbols function from R-3.0.0, plus some changes to
avoid possible overflow and unitialized field problems.
 
 
87-lapack:
 
Interface from base to LAPACK using .Internal rather than .Call, 
similarly to R-3.0.0.
 
 
87-matprod:
 
New version of matprod with bug fix and improved performance
for matprod_trans2.
 
 
87-mods:
 
Miscellaneous mods.

Now abort when protection stack imbalance detected.

Speed up to rbind.data.frame in simple cases.  New version of codetools
that makes better use of this.

Bug fixes.

Tuning adjustments.
 
 
87-pkgs:
 
Changes to make use of pqR package repository more convenient.
 
 
87-recommended:
 
Updates to versions recommended packages that are included.
 
 
87-tests:
 
Improvements to testing.

Adds test for correctness when scalar stack size is exceeded.

More matprod tests.
 
 
88-deriv:
 
Incorporate extensions to deriv from R-3.4.0.
 
 
88-fixes:
 
Fixes after pqR-2018-11-18, and then after 2019-02-19.

Includes doc fixes for standard distributions.

Fix from R-3.1.1 for problem with update.formula(~1, ~. - y)
 
 
88-mods:
 
Modifications that are feature-related.

Allows ... as an expression if it corresponds to just one argument.

Changes to handling of dims for arithmetic and relational operators,
and fix of related documentation bug.

 
 
88-perf:
 
Miscellaneous performance improvements.

Faster is.na, etc. for scalars.  Also does bug fix for is.na(NULL).

Pass variants to expr evaluated by switch.

Speed of sampling without replacement improved for some cases, and
overhead reduced for small cases of sample.

Improved 'local'.

Reduced interpretive overhead.
 
 
88-tests:
 
Changes to tests.

Speeds up and improves matprod tests.  Uses mods in 88-mods.
 
 
89-gradient:
 
Implement automatic gradient computations.
 
 
90-gradient:
 
Further implementation of automatic gradient computations, following
on 89-gradient, which only handled scalars wrt scalars.
 
 
91-gradient:
 
More work on gradients, implementing non-scalar numeric values 
as values and variables differentiated w.r.t.

Implements a full version of the facility (but without a few base
functions handling derivatives, and with 'as' for compute gradient
only allowing the actual jacobian).  But does completely naive
forward differentiation.



 
 
92-gradient:
 
Modifications to gradient scheme to be more efficient than
naive forward differentiation.
 
 
92-install:
 
Fix installation problems:

   Use -fno-optimize-sibling-calls with gfortran-7 or later, to avoid
   C-Fortran interface problem.

   Use -fallow-argument-mismatch to accomodate old Fortran code with 
   gfortran-10.

   Avoid inadvertent use of 'common', so the -fno-common default in
   gcc-10 will work.

Also, automatically add -ffp-contract=off to ensure reproducible arithmetic,
by disabling (eg) fused multiply-add.  Check that fused multiply-add isn't
done on startup.
 
 
92-listops:
 
Implement arithmetic operations on lists, dispatching to
R-level +.list, -.list, etc. functions.