
The ChangeLog for data.table is the SVN commit log itself :
    $ svn log svn://svn.r-forge.r-project.org/svnroot/datatable

This NEWS file summarises the main changes.


        *********************************************
        **                                         **
        **   CHANGES IN DATA.TABLE VERSION 1.6.6   **
        **                                         **
        *********************************************

BUG FIXES

    o   Tests using .Call("Rf_setAttrib",...) passed CRAN acceptance
        checks but failed on many (but not all) platforms. Fixed.
        Thanks (and apologies) to Prof Brian Ripley for investigating
        the issue.


        *********************************************
        **                                         **
        **   CHANGES IN DATA.TABLE VERSION 1.6.5   **
        **                                         **
        *********************************************

NEW FEATURES

    o   The LHS of := may now be column names or positions
        when with=FALSE; e.g.,
        
            DT[,c("d","e"):=NULL,with=FALSE]
            DT[,4:5:=NULL,with=FALSE]
            newcolname="myname"
            DT[,newcolname:=3.14,with=FALSE]
        
        This implements FR#1499 'Ability to efficiently remove a
        vector of column names' by Timothee Carayol in addition to
        creating and assigning to multiple columns. We still plan
        to allow multiple := without needing with=FALSE, in future.
        
    o   setkey(DT,...) now returns DT (invisibly) rather than NULL.
        This is to allow compound statements; e.g.,
            setkey(DT,x)["a"]

    o   setkey (and key<-) are now more efficient when the data happens
        to be already sorted by the key columns; e.g., when data is
        loaded from ordered files.

    o   If DT is already keyed by the columns passed to setkey (or
        key<-), the key is now rebuilt and checked rather than skipping
        for efficiency. This is to save needing to know to drop the key
        first to rebuild an invalid key. Invalid keys can arise by going
        'under the hood'; e.g., attr(DT,"sorted")="z", or somehow ending
        up with unordered factor levels. A warning is issued so the root
        cause can be fixed. Thanks to Timothee Carayol for highlighting.
        
    o   A new copy() function has been added, FR#1501. This copies a
        data.table (retaining its key, if any) and should now be used to
        copy rather than data.table(). Reminder: data.tables are not
        copied on write by setkey, key<- or :=.


BUG FIXES

    o   DT[,z:=a/b] and DT[a>3,z:=a/b] work again, where a and
        b are columns of DT. Thanks to Chris Neff for reporting,
        and his patience.
        
    o   Numeric columns with class attributes are now correctly
        coerced to integer by setkey and ad hoc by. The error
        similar to 'fractional data cannot be truncated' should now
        only occur when that really is true. A side effect of
        this is that ad hoc by and setkey now work on IDate columns
        which have somehow become numeric; e.g., via rbind(DF,DF)
        as reported by Chris Neff.
        
    o   .N is now 0 (rather than 1) when no rows in x match the
        row in i, fixing bug #1532. Thanks to Yang Zhang for
        reporting.
        
    o   Compatibility with package IRanges has been restored. Both
        data.table and IRanges mask cbind and rbind. When data.table's
        cbind is found first (if it is loaded after IRanges) and the
        first argument is not data.table, it now delegates to the next
        package on the search path (and above that), one or more of which
        may also mask cbind (such as IRanges), rather than skipping
        straight to base::cbind. So, it no longer matters which way around
        data.table and IRanges are loaded, fixing #1534. Thanks to Steve
        Lianoglou for reporting.
        
        
USER VISIBLE CHANGES

    o   setkey's verbose messages expanded.


        *********************************************
        **                                         **
        **   CHANGES IN DATA.TABLE VERSION 1.6.4   **
        **                                         **
        *********************************************

NEW FEATURES

    o   DT[colA>3,which=TRUE] now returns row numbers rather
        than a logical vector, for consistency.

BUG FIXES

    o   Changing a keyed column name now updates the key, too,
        so an invalid key no longer arises, fixing #1495.
        Thanks to Chris Neff for reporting.
        
    o   := already warned when a numeric RHS is coerced to
        match an integer column's type. Now it also warns when
        numeric is coerced to logical, and integer is coerced
        to logical, fixing #1500. Thanks to Chris Neff for
        reporting. 

    o   The result of DT[,newcol:=3.14] now includes the new
        column correctly, as well as changing DT by reference,
        fixing #1496. Thanks to Chris Neff for reporting.
        
    o   :=NULL to remove a column (instantly, regardless of table
        size) now works rather than causing a segfault in some
        circumstances, fixing #1497. Thanks to Timothee Carayol
        for reporting.
        
    o   Previous within() and transform() behaviour restored; e.g.,
        can handle multiple columns again. Thanks to Timothee Carayol
        for reporting.
        
    o   cbind(DT,DF) now works, as does rbind(DT,DF), fixing #1512.
        Thanks to Chris Neff for reporting. This was tricky to fix due
        to nuances of the .Internal dispatch code in cbind and rbind,
        preventing S3 methods from working in all cases.
        R will now warn that cbind and rbind have been masked when
        the data.table package is loaded. These revert to base::cbind
        and base::rbind when the first argument is not data.table.
        
    o   Removing multiple columns now works (again) using
        DT[,c("a","b")]=NULL, or within(DT,rm(a,b)), fixing #1510.
        Thanks to Timothee Carayol for reporting.
        

NOTES

    o   The package uses two features (packageVersion() and \href in Rd) 
        added to R 2.12.0 and is therefore dependent on that release.
        A 'spurious warning' when checking a package using \href was
        fixed in R 2.12.2 patched but we believe that warning can safely
        be ignored in versions >= 2.12.0 and < 2.12.2 patched.
                
        
        *********************************************
        **                                         **
        **   CHANGES IN DATA.TABLE VERSION 1.6.3   **
        **                                         **
        *********************************************

NEW FEATURES
        
    o   Ad hoc grouping now returns results in the same order each 
        group first appears in the table, rather than sorting the
        groups. Thanks to Steve Lianoglou for highlighting. The order
        of the rows within each group always has and always will be 
        preserved. For larger datasets a 'keyed by' is still faster;
        e.g., by=key(DT).
        
    o   The 'key' argument of data.table() now accepts a vector of
        column names in addition to a single comma separated string
        of column names, for consistency. Thanks to Steve Lianoglou
        for highlighting.
        
    o   A new argument '.SDcols' has been added to [.data.table. This
        may be character column names or numeric positions and
        specifies the columns of x included in .SD. This is useful
        for speed when applying a function through a subset of
        (possibly very many) columns; e.g.,
            DT[,lapply(.SD,sum),by="x,y",.SDcols=301:350]

    o   as(character, "IDate") and as(character, "ITime") coercion
        functions have been added. Enables the user to declaring colClasses
        as "IDate" and "ITime" in the various read.table (and sister)
        functions. Thanks to Chris Neff for the suggestion.
        
    o   DT[i,j]<-value is now handled by data.table in C rather
        than falling through to data.frame methods, FR#200. Thanks to
        Ivo Welch for raising speed issues on r-devel, to Simon Urbanek
        for the suggestion, and Luke Tierney and Simon for information
        on R internals.

        [<- syntax still incurs one working copy of the whole
        table (as of R 2.13.1) due to R's [<- dispatch mechanism
        copying to `*tmp*`, so, for ultimate speed and brevity,
        the operator := may now be used in j as follows.
        
    o   := is now available to j and means assign to the column by
        reference; e.g.,

            DT[i,colname:=value]
        
        This syntax makes no copies of any part of memory at all.
        
        m = matrix(1,nrow=100000,ncol=100)
        DF = as.data.frame(m)
        DT = as.data.table(m)
        
        system.time(for (i in 1:1000) DF[i,1] <- i)
             user  system elapsed 
          287.062 302.627 591.984 
        
        system.time(for (i in 1:1000) DT[i,V1:=i])
             user  system elapsed 
            1.148   0.000   1.158     ( 511 times faster )

        := in j can be combined with all types of i, such as binary
        search, and used to add and remove columns efficiently.
        Fast assigning within groups will be implemented in future.
        
        Reminder that data.frame and data.table both allow columns
        of mixed types, including columns which themselves may be
        type list; matrix may be one (atomic) type only.
        
        *Please note*, := is new and experimental.
        

BUG FIXES

    o   merge()ing two data.table's with user-defined `suffixes`
        was getting tripped up when column names in x ended in
        '.1'. This resulted in the `suffixes` parameter being
        ignored.
        
    o   Mistakenly wrapping a j expression inside quotes; e.g.,
            DT[,list("sum(a),sum(b)"),by=grp]
        was appearing to work, but with wrong column names. This
        now returns a character column (the quotes should not
        be used). Thanks to Joseph Voelkel for reporting.
        
    o   setkey has been made robust in several ways to fix issues
        introduced in 1.6.2: #1465 ('R crashes after setkey')
        reported by Eugene Tyurin and similar bug #1387 ('paste()
        by group to create long comma separated strings can crash')
        reported by Nicolas Servant and Jean-Francois Rami. This
        bug was not reproducible so we are especially grateful for
        the patience of these people in helping us find, fix and
        test it.
        
    o   Combining a join, j and by together in one query now works
        rather than giving an error, fixing bug #1468. Discovered
        indirectly thanks to a post from Jelmer Ypma.
        
    o   Invalid keys no longer arise when a non-data.table-aware
        package reorders the data; e.g.,
            setkey(DT,x,y)
            plyr::arrange(DT,y)       # same as DT[order(y)]
        This now drops the key to avoid incorrect results being
        returned the next time the invalid key is joined to. Thanks
        to Chris Neff for reporting.


USER-VISIBLE CHANGES

    o   The startup banner has been shortened to one line.
    
    o   data.table does not support POSIXlt. Almost unbelievably
        POSIXlt uses 40 bytes to store a single datetime. If it worked
        before, that was unintentional. Please see ?IDateTime, or any
        other date class that uses a single atomic vector. This is
        regardless of whether the POSIXlt is a key column, or not. This
        resolves bug #1481 by documenting non support in ?data.table.
        

DEPRECATED & DEFUNCT

   o    Use of the DT() alias in j is no longer caught for backwards
        compatibility and is now fully removed. As warned in NEWS
        for v1.5.3, v1.4, and FAQs 2.6 and 2.7.


        *********************************************
        **                                         **
        **   CHANGES IN DATA.TABLE VERSION 1.6.2   **
        **                                         **
        *********************************************

NEW FEATURES

   o    setkey no longer copies the whole table and should be
        faster for large tables. Each column is reordered by reference
        (in C) using one column of working memory, FR#1006. User
        defined attributes on the original table are now also
        retained (thanks to Thell Fowler for reporting).
        
   o    A new symbol .N is now available to j, containing the
        number of rows in the group. This may be useful when
        the column names are not known in advance, for
        convenience generally, and for efficiency.
        

        *********************************************
        **                                         **
        **   CHANGES IN DATA.TABLE VERSION 1.6.1   **
        **                                         **
        *********************************************
        
NEW FEATURES

   o    j's environment is now consistently reused so
        that local variables may be set which persist
        from group to group; e.g., incrementing a group
        counter :
            DT[,list(z,groupInd<-groupInd+1),by=x]
        Thanks to Andreas Borg for reporting.

   o    A new symbol .BY is now available to j, containing 1 row
        of the current 'by' variables, type list. 'by' variables
        may also be used by name, and are now length 1 too. This
        implements FR#1313. FAQ 2.10 has been updated accordingly.
        Some examples :
            DT[,sum(x)*.BY[[1]],by=eval(byexp)]
            DT[,sum(x)*mylookuptable[J(y),z],by=y]
            DT[,list(sum(unlist(.BY)),sum(z)),by=list(x,y%%2)]

   o    i may now be type list, and works the same as when i
        is type data.table. This saves needing J() in as many
        situations and may be a little more efficient. One
        application is using .BY directly in j to join to a
        relatively small lookup table, once per group, for space
        and time efficiency. For example :
            DT[,list(GROUPDATA[.BY]$name,sum(v)),by=grp]


BUG FIXES

   o    A 'by' character vector of column names now
        works when there are less rows than columns; e.g.,
            DT[,sum(x),by=key(DT)]  where nrow(DT)==1.
        Many thanks to Andreas Borg for report, proposed
        fix and tests.
        
   o    Zero length columns in j no longer cause a crash in
        some circumstances. Empty columns are filled with NA
        to match the length of the longest column in j.
        Thanks to Johann Hibschman for bug report #1431.
        
   o    unique.data.table now calls the same internal code
        (in C) that grouping calls. This fixes a bug when
        unique is called directly by user, and, NA exist
        in the key (which might be quite rare). Thanks to
        Damian Betebenner for bug report. unique should also
        now be faster.
        
   o    Variables in calling scope can now be used in j when
        i is logical or integer, fixing bug #1421. Thanks
        to Alexander Peterhansl for reporting.

        
USER-VISIBLE CHANGES

    o   ?data.table now documents that logical i is not quite
        the same as i in [.data.frame. NA are treated as FALSE,
        and DT[NA] returns 1 row of NA, unlike [.data.frame.
        Three points have been added to FAQ 2.17. Thanks to
        Johann Hibschman for highlighting.
        
    o   Startup banner now uses packageStartupMessage() so the
        banner can be suppressed by those annoyed by banners,
        whilst still being helpful to new users.



        *********************************************
        **                                         **
        **   CHANGES IN DATA.TABLE VERSION 1.6     **
        **                                         **
        *********************************************

NEW FEATURES

   o    data.table now plays nicely with S4 classes. Slots can be
        defined to be S4 objects, S4 classes can inherit from data.table,
        and S4 function dispatch works on data.table objects. See the
        tests in inst/tests/test-S4.R, and from the R prompt:
        ?"data.table-class"

   o    merge.data.table now works more like merge.data.frame:
        (i) suffixes are consistent with merge.data.frame; existing users
        may set options(datatable.pre.suffixes=TRUE) for backwards
        compatibility.
        (ii) support for 'by' argument added (FR #1315).
        However, X[Y] syntax is preferred; some users never use merge.
  

BUG FIXES

   o    by=key(DT) now works when the number of rows is not
        divisible by the number of groups (#1298, an odd bug).
        Thanks to Steve Lianoglou for reporting.
        
   o    Combining i and by where i is logical or integer subset now
        works, fixing bug #1294. Thanks to Johann Hibschman for
        contributing a new test.
   
   o    Variable scope inside [[...]] now works without a workaround
        required. This can be useful for looking up which function 
        to call based on the data e.g. DT[,fns[[fn]](colA),by=ID].
        Thanks to Damian Betebenner for reporting.
        
   o    Column names in self joins such as DT[DT] are no longer
        duplicated, fixing bug #1340. Thanks to Andreas Borg for
        reporting.
        

USER-VISIBLE CHANGES

   o    Additions and updates to FAQ vignette. Thanks to Dennis
        Murphy for his thorough proof reading.
        
   o    Welcome to Steve Lianoglou who joins the project
        contributing S4-ization, testing using testthat, and more.
        
   o    IDateTime is now linked from ?data.table. data.table users
        unaware of IDateTime, please do take a look. Tom added
        IDateTime in v1.5 (see below).


        *********************************************
        **                                         **
        **   CHANGES IN DATA.TABLE VERSION 1.5.3   **
        **                                         **
        *********************************************       

NEW FEATURES

   o    .SD no longer includes 'by' columns, FR#978. This resolves
        the long standing annoyance of duplicated 'by' columns
        when the j expression returns a subset of rows from .SD. 
        For example, the following query no longer contains
        a redundant 'colA.1' duplicate.
            DT[,.SD[2],by=colA] #  2nd row of each group
        Any existing code that uses .SD may require simple
        changes to remove workarounds.

   o    'by' may now be a character vector of column names.
        This allows syntax such as DT[,sum(x),by=key(DT)].

   o    X[Y] now includes Y's non-join columns, as most users
        naturally expect, FR#746. Please do use j in one step
        (i.e. X[Y,j]) since that merges just the columns j uses and
        is much more efficient than X[Y][,j] or merge(X,Y)[,j].

   o    The 'Join Inherited Scope' feature is back on, FR#1095. This
        is consistent with X[Y] including Y's non-join columns, enabling
        natural progression from X[Y] to X[Y,j]. j sees columns in X
        first then Y. 
        If the same column name exists in both X and Y, the data in
        Y can be accessed via a prefix "i." (not yet implemented).

   o    Ad hoc by now coerces double to integer (provided they are
        all.equal) and character to factor, FR#1051, as setkey
        already does.

USER-VISIBLE CHANGES

   o    The default for mult is now "all", as planned and
        prior notice given in FAQ 2.2.

   o    ?[.data.table has been merged into ?data.table and updated,
        simplified, corrected and formatted.

DEPRECATED & DEFUNCT

   o    The DT() alias is now fully deprecated, as warned
        in NEWS for v1.4, and FAQs 2.6 and 2.7.


        *********************************************
        **                                         **
        **   CHANGES IN DATA.TABLE VERSION 1.5.2   **
        **                                         **
        *********************************************       

NEW FEATURES

   o    'by' now works when DT contains list() columns i.e.
        where each value in a column may itself be vector
        or where each value is a different type. FR#1092.

   o    The result from merge() is now keyed. FR#1244.


BUG FIXES

    o   eval of parse()-ed expressions now works without
        needing quote() in the expression, bug #1243. Thanks
        to Joseph Voelkel for reporting.

    o   the result from the first group alone may be bigger
        than the table itself, bug #1245. Thanks to
        Steve Lianoglou for reporting.

    o   merge on a data.table with a single key'd column only
        and all=TRUE now works, bug #1241. Thanks to
        Joseph Voelkel for reporting.

    o   merge()-ing by a column called "x" now works, bug
        #1229 related to variable scope. Thanks to Steve
        Lianoglou for reporting.


        *********************************************
        **                                         **
        **   CHANGES IN DATA.TABLE VERSION 1.5.1   **
        **                                         **
        *********************************************

BUG FIXES

    o   Fixed inheritance for other packages importing or depending
        on data.table, bugs #1093 and #1132. Thanks to Koert Kuipers
        for reporting.

    o   data.table queries can now be used at the debugger() prompt,
        fixing bug #1131 related to inheritance from data.frame.


        *********************************************
        **                                         **
        **   CHANGES IN DATA.TABLE VERSION 1.5     **
        **                                         **
        *********************************************


NEW FEATURES

    o   data.table now *inherits* from data.frame, for functions and
        packages which _only_ accept data.frame, saving time and
        memory of conversion. A data.table is a data.frame too;
        is.data.frame() now returns TRUE.
    
    o   Integer-based date and time-of-day classes have been 
        introduced. This allows dates and times to be used as keys
        more easily. See as.IDate, as.ITime, and IDateTime.
        Conversions to and from POSIXct, Date, and chron are
        supported.
    
    o   [<-.data.table and $<-.data.table were revised to check for
        changes to the key-ed columns. [<-.data.table also now allows
        data.table-style indexing for i. Both of these changes may
        introduce incompatibilities for existing code.
        
    o   Logical columns are now allowed in keys. Logical columns (and
        expressions that evaluate to logical) are now allowed in 'by'.
        Thanks to David Winsemius for highlighting.
            
        
BUG FIXES

    o   DT[,5] now returns 5 as FAQ 1.1 says, for consistency
        with DT[,c(5)] and DT[,5+0]. DT[,"region"] now returns
        "region" as FAQ 1.2 says. Thanks to Harish V for reporting.
        
    o   When a quote()-ed expression q is passed to 'by' using
        by=eval(q), the group column names now come from the list
        in the expression rather than the name 'q' (bug #974) and,
        multiple items work (bug #975). Thanks to Harish V for
        reporting.
        
    o   quote()-ed i and j expressions receive similar fixes, bugs
        #977 and #1058. Thanks to Harish V and Branson Owen for
        reporting.
        
    o   Multiple errors (grammar, format and spelling) in intro.Rnw
        and faqs.Rnw corrected by Dennis Murphy. Thank you.
        
    o   Memory is now reallocated in rare cases when the up front
        allocate for the result of grouping is insufficient. Bug
        #952 raised by Georg V, and also reported by Harish. Thank
        you.
        
    o   A function call foo(arg=sum(b)) now finds b in DT when foo
        contains DT[,eval(substitute(arg)),by=a], fixing bug #1026.
        Thanks to Harish V for reporting.
        
    o   If DT contains column 'a' then DT[J(unique(a))] now finds
        'a', fixing bug #1005. Thanks to Branson Owen for reporting.
        
    o   'by' on no data (for example when 'i' returns no rows) now
        works, fixing bug #709.
        
    o   'by without by' now heeds nomatch=NA, fixing bug #1015.
        Thanks to Harish V for reporting.
        
    o   DT[NA] now returns 1 row of NA rather than the whole table
        via standard NA logical recycling. A single NA logical is
        a special case and is now replaced by NA_integer_. Thanks
        to Branson Owen for highlighting the issue.
        
    o   NROW removed from data.table, since the is.data.frame() in
        base::NROW now returns TRUE due to inheritance. Fixes bug
        #1039 reported by Bradley Buchsbaum. Thank you.
        
    o   setkey() now coerces character to factor and double to
        integer (provided they are all.equal), fixing bug #953.
        Thanks to Steve Lianoglou for reporting.
        
    o   'by' now accepts lists from the calling scope without the
        work around of wrapping with as.list() or {}, fixing bug
        #1060. Thanks to Johann Hibschman for reporting.
        
        
NOTES

    o   The package uses the 'default' option of base::getOption,
        and is therefore dependent on R 2.10.0. Updated DESCRIPTION
        file accordingly. Thanks to Christian Hudon for reporting.


        *********************************************
        **                                         **
        **   CHANGES IN DATA.TABLE VERSION 1.4.1   **
        **                                         **
        *********************************************


NEW FEATURES

    o   Vignettes tidied up.
    
        
BUG FIXES

    o   Out of order levels in key columns are now sorted by
        setkey. Thanks to Steve Lianoglou for reporting.

        


        *******************************************
        **                                       **
        **   CHANGES IN DATA.TABLE VERSION 1.4   **
        **                                       **
        *******************************************


NEW FEATURES

    o   'by' faster. Memory is allocated first for the result, then
    populated directly by the result of j for each group. Can be 10
    or more times faster than tapply() and aggregate(), see
    timings vignette.
    
    o   j should now be a list(), not DT(), of expressions. Use of
    j=DT(...) is caught internally and replaced with j=list(...).
    
    o   'by' may be a list() of expressions. A single column name
    is automatically list()-ed for convenience. 'by' may still be
    a comma separated character string, as before.
        DT[,sum(x),by=region]                     # new
        DT[,sum(x),by=list(region,month(date))]   # new
        DT[,sum(x),by="region"]                   # old, ok too
        DT[,sum(x),by="region,month(date)"]       # old, ok too
         
    o   key() and key<- added. More R-style alternatives to getkey()
    and setkey().
    
    o   haskey() added. Returns TRUE if a table has a key.
    
    o   radix sorting is now column by column where possible, was
    previously all or nothing. Helps with keys of many columns.
    
    o   Added format method.
    
    o   22 tests added to test.data.table(), now 149.
    
    o   Three vignettes added : FAQ, Intro & Timings


DEPRECATED & DEFUNCT

    o   The DT alias is removed. Use 'data.table' instead to create
    objects. See 2nd new feature above.
    
    o   RUnit framework removed.
    test.data.table() is called from examples in .Rd so 'R CMD check'
    will run it. Simpler. An eval(body(test.data.table))
    is also in the .Rd, to catch namespace issues.
    
    o   Dependency on package 'ref' removed.
    
    o   Arguments removed:  simplify, incbycols and byretn.
    Grouping is simpler now, these are superfluous.
    
    
BUG FIXES

    o   Column classes are now retained by subset and grouping.
    
    o   tail no longer fails when a column 'x' exists.

    
KNOWN PROBLEMS

    o   Minor : Join Inherited Scope not working, contrary
        to the documentation.


NOTES

    o   v1.4 was essentially the branch at rev 44, reintegrated
    at rev 78.




        *******************************************
        **                                       **
        **   CHANGES IN DATA.TABLE VERSION 1.3   **
        **                                       **
        *******************************************
        
        
NEW FEATURES

    o   Radix sorting added. Speeds up setkey and add-hoc 'by'
    by factor of 10 or more.
    
    o   Merge method added, much faster than base::merge method
    of data.frame.
    
    o   'by' faster. Logic moved from R into C. Memory is
    allocated for the largest group only, then re-used.
    
    o   The Sub Data is accessible as a whole by j using object
    .SD. This should only be used in rare circumstances. See FAQ.
    
    o   Methods added : duplicated, unique, transform, within,
    [<-, t, Math, Ops, is.na, na.omit, summary
    
    o   Column name rules improved e.g. dots now allowed.
    
    o   as.data.frame.data.table rownames improved.
    
    o   29 tests added to test.data.table(), now 127.
        
        
USER-VISIBLE CHANGES

    o   Default of mb changed, now tables(mb=TRUE)


DEPRECATED & DEFUNCT

    o   ... removed in [.data.table.
    j may not be a function, so this is now superfluous.
    
    
BUG FIXES

    o   Incorrect version warning with R 2.10+ fixed.
    
    o   j enclosure raised one level. This fixes some bugs
    where the j expression previously saw internal variable
    names. It also speeds up grouping a little.


NOTES

    o   v1.3 was not released to CRAN. R-Forge repository only.




        ********************************************
        **                                        **
        **   VERSION 1.2 RELEASED CRAN AUG 2008   **
        **                                        **
        ********************************************


