=== 0.0.1 / 2012-04-10 * 1 major enhancement * Initial alpha release === 0.0.2 / 2012-09-21 * 15 major enhancements * Second alpha release * Rewrote NMatrix in C++0x and C++11 using templates, namespaces; removed Ruby generators and CAST parser * Added preliminary C API * Slicing and referencing support for dense and list matrices (by @flipback) * BLAS level-3 xTRSM algorithm added for rationals and BLAS types * LAPACK support added, including partially working xGETRF subroutine * Element-wise comparisons now return byte-matrices * Element-wise operations on list matrices may alter the default value of the return matrix * Element-wise division behaves like Ruby division * Improved MATLAB .MAT v5 file reading * clang support * `==` operator now used for matrix equality, `=~` and `!~` for element-wise comparisons * Dense `each` returns an Enumerator when called without a block * Sped up list storage item deletion, fixed bugs * List matrix-to-hash conversion with `to_h` * Note: Element-wise list operations current disabled === 0.0.3 / 2013-01-18 * 8 major enhancements * Matrix-scalar operations (dense, list) * Shortcuts for matrix creation (by @agarie) * Access to most ATLAS-implemented LAPACK functions for those with ATLAS' CLAPACK interface: xGETRF, xGETRI, xGETRS, xGESV, xPOTRF, xPOTRI, xPOTRS, xPOSV, xLASWP, xSCAL, xLAUUM * Access to additional ATLAS-implemented BLAS functions: xTRMM, xSYRK, xHERK, xROT, xROTG * Non-ATLAS versions of CLAPACK functions: xLASWP, xSCAL, xLAUUM, xROT * Matrix inversion (LU and Cholesky; requires CLAPACK) * LU factoring with and without CLAPACK * Native matrix I/O for dense (supporting upper, lower, hermitian, skew, symmetric, and general) and yale (general only); excludes Ruby objects currently * 2 bug fixes: * Yale-to-list casting * Now requires packable-1.3.5 or higher, fixing a problem with MATLAB .mat v5 file I/O (specific to doubles) === 0.0.4 / 2013-05-17 * 3 major enhancements * Added a more user-friendly interface for cblas_rot in the form of NMatrix::BLAS::rot * Added to_hash for Yale matrices * Improved source code documentation (by @agarie) * 4 minor enhancements * Spec clean-up (by @masaomi) * Made it possible to request a different itype internally for Yale matrices * Improved space usage of Yale slice-by-copying, which was requesting more space than needed * Improved compile-time Mac OS X and Ubuntu library searching * 8 bug fixes: * NMatrix::BLAS::gemv segfaults * Fixed Yale matrix slice-by-copy write error where default itypes (which are based on shape) differ, and a separate problem where incorrect IJA and A entries were written. * NVector-scalar operations and NVector-NVector element-wise options now return an NVector instead of an NMatrix * Addressed problems with segmentation faults during iteration (by @cjfuller) * Addressed Ubuntu/Debian installation problems (incompatibility with apt-supplied atlas) * Fixed transpose behavior following slice-by-reference (by @cjfuller) * Fixed gem install command in Rakefile (by @jpmckinney) * Fixed Spanish language compile issue (by @imcsk8 and @agarie) === 0.0.5 / 2013-07-09 * 4 major enhancements * NVector orientation is now controlled by its shape, not by the @orientation property * NVector default orientation is now a row vector rather than a column, as this is more efficient for Yale storage * NVector objects may now be created with dtypes other than dense * Exposure of additional ATLAS-implemented BLAS functions, including native rational and Ruby object support, for xANUM (sum of the absolute values of a vector) and xNRM2 (2-norm of a vector); and Ruby helper functions BLAS::anum and BLAS::nrm2 which should do more careful argument sanity checking * 9 minor enhancements * Added #yale_vector_insert to NMatrix::YaleFunctions, to speed up insertion of multiple items into a Yale matrix * Added #yale_nd_row, #yale_nd_row_as_hash, #yale_nd_row_as_array, #yale_nd_row_as_set, #yale_nd_row_as_sorted_set, #yale_row, #yale_row_as_hash, #yale_row_as_array, #yale_row_as_set, #yale_row_as_sorted_set, #yale_nd_row_size to NMatrix::YaleFunctions in order to speed up getting multiple items from some row of a Yale matrix * Improved #yale_ija, #yale_a, #yale_d by allowing an optional index argument, which returns a single array value instead of copying and returning the entire array * Improved sorting algorithm for Yale matrix multiplication; instead of selection sort, now uses quicksort; and subs in insertion sort for small partitions * Slicing a single row or column now returns an NVector instead of an NMatrix (does not yet work for n-dimensional matrices) * Improved function documentation for NVector and NMatrix * Added #min, #max, #to_a, #shuffle, #shuffle!, #absolute_sum, #norm2 functions to NVector * Aliased missing dimension of NVector#each_stored_with_indices to #each_stored_with_index, which only yields a value and i or j (not both i and j) depending on the vector orientation * Added #each_row, #each_column to NMatrix * 5 bug fixes: * Dense iterators now return self (an NMatrix) in order to be consistent with Ruby Array behavior (by @cjfuller) * Fixed Yale resize problem (by @v0dro) * Fixed Yale nx1 times 1xn multiplication problem * Fixed Yale sorting-following-multiplication problem * NMatrix::read() now raises an exception when asked to read a file that does not exist === 0.0.6 / 2013-08-09 * 8 major enhancements: * Refactored iteration, so that each storage type now has each of: #each, #each_with_indices, #each_stored_with_indices * Added element-wise power function (**) for dense matrices (by @agarie) * Dramatically improved matrix element-wise and scalar functions so C++ templates are no longer necessary; element-wise operations may now be written in protected Ruby methods that look like NMatrix#__list_elementwise_op__ and NMatrix#__list_scalar_op__ * Element-wise and scalar operations that might return a true or false now return Ruby matrices * Yale element-wise and scalar operations have been added * Yale is now allowed to have a non-zero default (specifically to permit true-false matrices and nil sparse bases) * Dramatically improved NMatrix#cast to allow for hashed options including a :default for list and yale casts * Dramatically improved speed of compilation * 14 minor enhancements: * Improved documentation for exposed BLAS and LAPACK functions * Allowed for use of BLAS::rot without cloning x and y (in-place plane rotation); removed unnecessary test of unfriendly version * Added more user-friendly cblas_xrotg implementation: BLAS::rotg * Moved NMatrix::YaleFunctions::yale_vector_insert to NMatrix#__yale_vector_set__, which is more consistent with behavior * Changed notations for protected stype-specific functions, which now look like __stype_method_name__, e.g., __yale_vector_set__ * Added NMatrix#__list_default_value__ protected function to get the initial (sparse) value for list matrices * Changed behavior and names of NMatrix::YaleFunctions methods which get column indices and cell contents by row, so that they now expect the :keys option (like Hash#keys) instead of :array, which doesn't make sense; name changes are as follows: yale_row_as_sorted_set -> yale_ja_d_keys_sorted_set_at yale_row_as_set -> yale_ja_d_keys_set_at yale_row_as_array -> yale_ja_d_keys_at yale_nd_row_as_sorted_set -> yale_ja_sorted_set_at yale_nd_row_as_set -> yale_ja_set_at yale_nd_row_as_array -> yale_ja_at Aliases are included but will be removed without notice. * Added NVector#sorted_indices and #binned_sorted_indices for use when running k-nearest neighbor searches on a distance matrix * Added NVector::logspace shortcut function (analogous to NVector::linspace) * Cleaned up code by removing monkey patches that we stopped using circa v0.0.2 (Array#min, Array#max, String#constantize, String#camelize, String#underscore) * Re-enabled element-wise mod (%) method * Added NMatrix::guess_dtype class method, which allows you to figure out what dtype (roughly) should be used for any given Ruby value (e.g., 3) * String and nil objects in NMatrix cells are no longer outlawed (but are not supported), provided they are of the :object dtype * NMatrix#diag shortcut for specifying sparse matrix with a user- specified diagonal array (by @ryanmt) * 3 bug fixes: * Corrected BLAS::rot bounds checking on optional n argument * Removed BLAS::rotg and BLAS::nrm2 code for rational numbers, as both involve a square root * Repaired list matrix element-wise functions