=== 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 === 0.0.7 / 2013-08-22 * 6 major enhancements: * Eliminated NVector in favor of NMatrix objects with #effective_dim smaller than #dim; added NVector-like functionality to NMatrix, sometimes with #respond_to? dependent upon matrix dimensions; allowed for NVector.new to continue to function as before, but now returns an NMatrix instead * Began major re-factoring of headers for math.cpp * Added two singular value decomposition functions for dense NMatrix objects, #gesvd and #gesdd, for floating point and complex dtypes * Added additional slicing shorthand, which uses hashes (e.g., n[0=>3,2] for n[0..3,2]), which may eventually allow users to use n[0:3,2] notation instead (needs Ruby core patch) * #[] and #[]= calls no longer need index on those matrix shape elements which are equal to 1 (e.g., vectors) * Yale slicing-by-reference has been added * 18 minor enhancements: * Added user-friendly NMatrix::LAPACK::laswp method * Added NMatrix#permute_columns! and NMatrix#permute_columns * Added NMatrix#abs to compute element-wise absolute values, and #abs_dtype to determine the dtype returned by a call to #abs on a given matrix (needed for RSpec) * Added NMatrix#size to compute the total number of cells in an NMatrix object (solely accounting for the shape, not sparsity) * Added RSpec monkey patches for #be_within to work with NMatrix objects; usable by requiring "nmatrix/rspec" * Added experimental NMatrix::LAPACK::lapack_gesvd function (which does NOT depend upon CLAPACK) (by @ryanmt and @mohawkjohn) * Added experimental non-LAPACK-dependent function NMatrix::LAPACK::lapack_gesdd * Added NMatrix#supershape method for getting the shape of a slice's parent or other ancestor, which may be useful for calling ATLAS and LAPACK functions on slices * Aliased NMatrix[] to function like N[] shortcut for matrix creation (by @agarie) * Added #layer for matrices with dimension greater than two (corresponds to #row and #column) * Added #rank and #each_rank generics for #row/#column/#layer and #each_row/#each_column/#each_layer respectively (#each_rank replaces #each_along_dim) * Replaced #reduce_along_dim with #inject_rank * NMatrix#to_a now works for up to two dimensional matrices; and returns a flattened array for single-row matrices * NMatrix#to_flat_a now returns a flattened array of all entries * Re-organized NMatrix Ruby sources into multiple files: math.rb for instance methods which are mathematical in nature or are essentially ATLAS/LAPACK/BLAS calls, enumerate.rb for methods involving enumeration; and existing shortcuts.rb for convenience functions and shortcut constructors, and nmatrix.rb for core functionality (#inspect, #to_h, #to_a, #to_s, #pretty_print, and so on) * Improved #pretty_print, which now also prints layers (the third dimension in a 3D matrix) * Re-factored some of dense slicing to remove some redundant code * Added shortcut functions #list?, #dense?, #yale? for quickly testing matrix storage type * 5 bug fixes: * Fixed compilation problem involving and STL headers * Fixed NMatrix#inverse problem with non-square matrices * Fixed invalid read problem detected by Valgrind for Yale element-wise subtraction in spec * Fixed conversion from Ruby object to Complex and Rational * Fixed memory leak in slicing