nmatrix 0.0.2 → 0.0.3

data/Gemfile

@@ -2,4 +2,4 @@
 source "http://rubygems.org"
 gemspec
 
-gem 'packable' # for Matlab IO
+gem 'packable', ">= 1.3.5"  # for Matlab IO

data/History.txt

@@ -6,7 +6,7 @@
 
 === 0.0.2 / 2012-09-21
 
-* Numerous major enhancements
+* 15 major enhancements
 
   * Second alpha release
 
@@ -14,7 +14,7 @@
 
   * Added preliminary C API
 
-  * Slicing and referencing support for dense and list matrices
+  * Slicing and referencing support for dense and list matrices (by @flipback)
 
   * BLAS level-3 xTRSM algorithm added for rationals and BLAS types
 
@@ -36,4 +36,32 @@
 
   * Sped up list storage item deletion, fixed bugs
 
-* Note: Element-wise list operations current disabled
+  * 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)

data/Manifest.txt

@@ -8,20 +8,25 @@ Guardfile
 spec/io_spec.rb
 spec/math_spec.rb
 spec/nmatrix_spec.rb
+spec/nmatrix_list_spec.rb
 spec/nmatrix_yale_spec.rb
 spec/nvector_spec.rb
 spec/slice_spec.rb
+spec/shortcuts_spec.rb
 spec/elementwise_spec.rb
 spec/blas_spec.rb
 spec/lapack_spec.rb
 spec/spec_helper.rb
 lib/nmatrix.rb
+lib/nmatrix/io/market.rb
 lib/nmatrix/io/mat5_reader.rb
 lib/nmatrix/io/mat_reader.rb
 lib/nmatrix/blas.rb
+lib/nmatrix/lapack.rb
 lib/nmatrix/monkeys.rb
 lib/nmatrix/nmatrix.rb
 lib/nmatrix/nvector.rb
+lib/nmatrix/shortcuts.rb
 lib/nmatrix/version.rb
 ext/nmatrix/data/complex.h
 ext/nmatrix/data/data.cpp

data/README.rdoc

@@ -27,49 +27,49 @@ are working on a {patch for Ruby/GSL}[https://github.com/SciRuby/rb-gsl].
 
 == Features
 
-The following features exist in the version of NMatrix (0.0.2) currently under development, and may or may not exist in
-0.0.1 (the current gem):
+The following features exist in the current version of NMatrix (0.0.2):
 
 * Matrix storage containers: dense, yale, list (more to come)
 * Data types: uint8, int8, int16, int32, int64, float32, float64, complex64, complex128, rational64, rational128
   (incomplete)
 * Conversion between storage and data types (except from-complex, and from-float-to-rational)
-* Element-wise operations and comparisons
+* Element-wise operations and comparisons for dense and yale
 * Matrix-matrix multiplication for dense (using ATLAS) and yale
 * Matrix-vector multiplication for dense (using ATLAS)
 * Dense and list matrix slicing and referencing
+* Native reading and writing of dense and yale matrices
+  * Optional compression for dense matrices with symmetry or triangularity: symmetric, skew, hermitian, upper, lower
 * Matlab .MAT v5 file input
 * C and C++ API
-* Level 3 BLAS internal implementations (no library) and ATLAS (with library) access:
-  * xGEMM
-  * xTRSM
+* BLAS internal implementations (no library) and ATLAS (with library) access:
+  * Level 1: xROT, xROTG (BLAS dtypes only)
+  * Level 2: xGEMV
+  * Level 3: xGEMM, xTRSM
 * LAPACK ATLAS access:
-  * xGETRF (experimental)
-
-=== Planned Features (Very Short Term)
-
-These features will exist in our second alpha release, 0.0.2 (incomplete, thus not yet available as a gem):
-
-* Yale matrix slicing and referencing
-* LU decomposition
-* LAPACK internal implementations (no library needed):
+  * xGETRF, xGETRI, xGETRS, xGESV (Gaussian elimination)
+  * xPOTRF, xPOTRI, xPOTRS, xPOSV (Cholesky factorization)
+  * xLASWP, xSCAL, xLAUUM
+* LAPACK-less internal implementations (no LAPACK needed and working on non-BLAS dtypes):
   * xGETRF
-
-The estimated release date for 0.0.2 is the end of August 2012.
+  * xLASWP, xSCAL
+  * xLAUUM (no LAPACK needed, but BLAS dtypes only)
+* LU decomposition
+* Matrix inversions (requires LAPACK; BLAS dtypes only)
+* Determinant calculation for BLAS dtypes
 
 === Planned Features (Short-to-Medium Term)
 
 These are features planned for NMatrix 0.1.0, our first beta.
 
-* calculation of determinant, trace, and eigenvalues (characteristic polynomial) (0.1.0)
-* Gaussian elimination
+* calculation of determinant (LAPACK-free), trace, and eigenvalues (characteristic polynomial) (0.1.0)
 * exponentials and square roots
-* matrix inversions
+* matrix inversions (LAPACK-free)
 * matrix decomposition/factorization
 * calculation of norms
 * tensor products
 * principal component analysis (PCA)
 * improved file I/O
+  * compression of yale symmetries in I/O
 * operation scheduling
 * parallelization of some types of operations
 * optimization of non-BLAS data types on BLAS-like operations (e.g., matrix multiplication for rational numbers)
@@ -83,30 +83,32 @@ For full instructions, please see sciruby.com/nmatrix. Generally, you should be
 
 However, you will need to install ATLAS with CBLAS first. Those directions can be found at our website.
 
-NOTE: The above command will not give you 0.0.2, which is not yet complete. To obtain 0.0.2, you should use the
-following sequence of commands:
+You can typically get the developer's build using the following sequence of commands:
 
     git clone https://github.com/SciRuby/nmatrix.git
     cd nmatrix/
     rake compile
     rake repackage
-    gem install pkg/nmatrix-0.0.2.gem
+    gem install pkg/nmatrix-0.0.4.gem
 
 If you get errors about clapack.h or cblas.h, figure out where your ATLAS headers are using:
 
-    locate clapack.h
+    locate clapack.h    # If you're a Mac user, we recommend you search for cblas.h instead.
 
 Then, tell your system:
 
     export C_INCLUDE_PATH=/usr/local/atlas/include
+    export CPLUS_INCLUDE_PATH=/usr/local/atlas/include
 
 Finally, try compiling again.
 
 == REQUIREMENTS:
 
-* ATLAS and LAPACK, probably
-* GCC 4.2
+* ATLAS
+* LAPACK, probably
+* GCC 4.3
 * Ruby 1.9
+* {packable}[http://github.com/marcandre/packable] 1.3.5 (used for I/O)
 
 == INSTALLATION:
 
@@ -126,7 +128,7 @@ Before commiting any code, you *MUST* read our
 
 == LICENSE:
 
-Copyright (c) 2012, The Ruby Science Foundation.
+Copyright (c) 2012--13, The Ruby Science Foundation.
 
 All rights reserved.
 

data/ext/nmatrix/binary_format.txt

@@ -0,0 +1,53 @@
+This is the proposed binary format for saving and loading NMatrix objects.
+
+Order is little-endian.
+
+List matrices should be converted to dense or yale matrices. There should be no serious need to load or save
+linked-list matrices, since these exist primarily in order to construct efficient yale matrices.
+
+
+First 64-bit block:
+* ui16 major (version)
+* ui16 minor
+* ui16 release
+* i16 NULL
+
+
+Second 64-bit block:
+* ui8 dtype
+* ui8 stype
+* ui8 itype # ui32 for dense
+* ui8 symm
+* i16 NULL
+* ui16 dim    # if 1, NVector; otherwise, NMatrix
+
+
+3rd - nth 64-bit block: shape
+
+itype sets the number of bytes allocated for each shape entry. Since only yale uses itype, dense will pretty
+much always be the UINT32 itype (see nmatrix.h). If the total number of bytes occupied by the shape array is
+less than 8, the rest of the 64-bit block will be padded with zeros.
+
+
+(n+1)th 64-bit block: depends on stype, symm
+
+symm is designed to reduce file size by allowing us to not save certain elements in symmetric, hermitian, skew-
+symmetric, and triangular matrices. These values will be defined in nmatrix.h; 0 indicates standard (no symmetry).
+In later versions, additional patterns may be defined which might even have less to do with symmetry than
+upper/lower do.
+
+When storing a symmetric matrix, we will only store the upper portion. If the matrix is lower triangular, only the
+lower portion will be stored.
+
+For dense, we simply store the contents of the matrix exactly as in memory (or just the upper-triangular part if
+symm is set).
+
+For yale, we store:
+* ui32 ndnz
+* ui32 length (AKA size, the number of elements in A/IJA that aren't nil/undefined)
+
+The latter will serve as the capacity when we read a Yale matrix.
+
+Then we store the a array, again padding with zeros so it's a multiple of 8 bytes.
+
+Then we store the ija array, padding with zeros so it's a multiple of 8 bytes.

data/ext/nmatrix/data/data.cpp

@@ -95,20 +95,20 @@ const size_t ITYPE_SIZES[nm::NUM_ITYPES] = {
 	sizeof(uint64_t),
 };
 
-const dtype_t Upcast[nm::NUM_DTYPES][nm::NUM_DTYPES] = {
-  { BYTE, INT8, INT16, INT32, INT64, FLOAT32, FLOAT64, COMPLEX64, COMPLEX128, RATIONAL32, RATIONAL64, RATIONAL128, RUBYOBJ},
-  { INT8, INT8, INT16, INT32, INT64, FLOAT32, FLOAT64, COMPLEX64, COMPLEX128, RATIONAL32, RATIONAL64, RATIONAL128, RUBYOBJ},
-  { INT16, INT16, INT16, INT32, INT64, FLOAT32, FLOAT64, COMPLEX64, COMPLEX128, RATIONAL32, RATIONAL64, RATIONAL128, RUBYOBJ},
-  { INT32, INT32, INT32, INT32, INT64, FLOAT32, FLOAT64, COMPLEX64, COMPLEX128, RATIONAL32, RATIONAL64, RATIONAL128, RUBYOBJ},
-  { INT64, INT64, INT64, INT64, INT64, FLOAT32, FLOAT64, COMPLEX64, COMPLEX128, RATIONAL32, RATIONAL64, RATIONAL128, RUBYOBJ},
-  { FLOAT32, FLOAT32, FLOAT32, FLOAT32, FLOAT32, FLOAT32, FLOAT64, COMPLEX64, COMPLEX128, FLOAT64, FLOAT64, FLOAT64, RUBYOBJ},
-  { FLOAT64, FLOAT64, FLOAT64, FLOAT64, FLOAT64, FLOAT64, FLOAT64, COMPLEX128, COMPLEX128, FLOAT64, FLOAT64, FLOAT64, RUBYOBJ},
-  { COMPLEX64, COMPLEX64, COMPLEX64, COMPLEX64, COMPLEX64, COMPLEX64, COMPLEX128, COMPLEX64, COMPLEX128, COMPLEX64, COMPLEX64, COMPLEX64, RUBYOBJ},
-  { COMPLEX128, COMPLEX128, COMPLEX128, COMPLEX128, COMPLEX128, COMPLEX128, COMPLEX128, COMPLEX128, COMPLEX128, COMPLEX128, COMPLEX128, COMPLEX128, RUBYOBJ},
-  { RATIONAL32, RATIONAL32, RATIONAL32, RATIONAL32, RATIONAL32, FLOAT64, FLOAT64, COMPLEX64, COMPLEX128, RATIONAL32, RATIONAL64, RATIONAL128, RUBYOBJ},
-  { RATIONAL64, RATIONAL64, RATIONAL64, RATIONAL64, RATIONAL64, FLOAT64, FLOAT64, COMPLEX64, COMPLEX128, RATIONAL64, RATIONAL64, RATIONAL128, RUBYOBJ},
-  { RATIONAL128, RATIONAL128, RATIONAL128, RATIONAL128, RATIONAL128, FLOAT64, FLOAT64, COMPLEX64, COMPLEX128, RATIONAL128, RATIONAL128, RATIONAL128, RUBYOBJ},
-  { RUBYOBJ, RUBYOBJ, RUBYOBJ, RUBYOBJ, RUBYOBJ, RUBYOBJ, RUBYOBJ, RUBYOBJ, RUBYOBJ, RUBYOBJ, RUBYOBJ, RUBYOBJ, RUBYOBJ}
+const nm::dtype_t Upcast[nm::NUM_DTYPES][nm::NUM_DTYPES] = {
+  { nm::BYTE, nm::INT8, nm::INT16, nm::INT32, nm::INT64, nm::FLOAT32, nm::FLOAT64, nm::COMPLEX64, nm::COMPLEX128, nm::RATIONAL32, nm::RATIONAL64, nm::RATIONAL128, nm::RUBYOBJ},
+  { nm::INT8, nm::INT8, nm::INT16, nm::INT32, nm::INT64, nm::FLOAT32, nm::FLOAT64, nm::COMPLEX64, nm::COMPLEX128, nm::RATIONAL32, nm::RATIONAL64, nm::RATIONAL128, nm::RUBYOBJ},
+  { nm::INT16, nm::INT16, nm::INT16, nm::INT32, nm::INT64, nm::FLOAT32, nm::FLOAT64, nm::COMPLEX64, nm::COMPLEX128, nm::RATIONAL32, nm::RATIONAL64, nm::RATIONAL128, nm::RUBYOBJ},
+  { nm::INT32, nm::INT32, nm::INT32, nm::INT32, nm::INT64, nm::FLOAT32, nm::FLOAT64, nm::COMPLEX64, nm::COMPLEX128, nm::RATIONAL32, nm::RATIONAL64, nm::RATIONAL128, nm::RUBYOBJ},
+  { nm::INT64, nm::INT64, nm::INT64, nm::INT64, nm::INT64, nm::FLOAT32, nm::FLOAT64, nm::COMPLEX64, nm::COMPLEX128, nm::RATIONAL32, nm::RATIONAL64, nm::RATIONAL128, nm::RUBYOBJ},
+  { nm::FLOAT32, nm::FLOAT32, nm::FLOAT32, nm::FLOAT32, nm::FLOAT32, nm::FLOAT32, nm::FLOAT64, nm::COMPLEX64, nm::COMPLEX128, nm::FLOAT64, nm::FLOAT64, nm::FLOAT64, nm::RUBYOBJ},
+  { nm::FLOAT64, nm::FLOAT64, nm::FLOAT64, nm::FLOAT64, nm::FLOAT64, nm::FLOAT64, nm::FLOAT64, nm::COMPLEX128, nm::COMPLEX128, nm::FLOAT64, nm::FLOAT64, nm::FLOAT64, nm::RUBYOBJ},
+  { nm::COMPLEX64, nm::COMPLEX64, nm::COMPLEX64, nm::COMPLEX64, nm::COMPLEX64, nm::COMPLEX64, nm::COMPLEX128, nm::COMPLEX64, nm::COMPLEX128, nm::COMPLEX64, nm::COMPLEX64, nm::COMPLEX64, nm::RUBYOBJ},
+  { nm::COMPLEX128, nm::COMPLEX128, nm::COMPLEX128, nm::COMPLEX128, nm::COMPLEX128, nm::COMPLEX128, nm::COMPLEX128, nm::COMPLEX128, nm::COMPLEX128, nm::COMPLEX128, nm::COMPLEX128, nm::COMPLEX128, nm::RUBYOBJ},
+  { nm::RATIONAL32, nm::RATIONAL32, nm::RATIONAL32, nm::RATIONAL32, nm::RATIONAL32, nm::FLOAT64, nm::FLOAT64, nm::COMPLEX64, nm::COMPLEX128, nm::RATIONAL32, nm::RATIONAL64, nm::RATIONAL128, nm::RUBYOBJ},
+  { nm::RATIONAL64, nm::RATIONAL64, nm::RATIONAL64, nm::RATIONAL64, nm::RATIONAL64, nm::FLOAT64, nm::FLOAT64, nm::COMPLEX64, nm::COMPLEX128, nm::RATIONAL64, nm::RATIONAL64, nm::RATIONAL128, nm::RUBYOBJ},
+  { nm::RATIONAL128, nm::RATIONAL128, nm::RATIONAL128, nm::RATIONAL128, nm::RATIONAL128, nm::FLOAT64, nm::FLOAT64, nm::COMPLEX64, nm::COMPLEX128, nm::RATIONAL128, nm::RATIONAL128, nm::RATIONAL128, nm::RUBYOBJ},
+  { nm::RUBYOBJ, nm::RUBYOBJ, nm::RUBYOBJ, nm::RUBYOBJ, nm::RUBYOBJ, nm::RUBYOBJ, nm::RUBYOBJ, nm::RUBYOBJ, nm::RUBYOBJ, nm::RUBYOBJ, nm::RUBYOBJ, nm::RUBYOBJ, nm::RUBYOBJ}
 };
 
 
@@ -123,7 +123,7 @@ const dtype_t Upcast[nm::NUM_DTYPES][nm::NUM_DTYPES] = {
 /*
  * Converts a RubyObject
  */
-void rubyval_to_cval(VALUE val, dtype_t dtype, void* loc) {
+void rubyval_to_cval(VALUE val, nm::dtype_t dtype, void* loc) {
   using namespace nm;
 	switch (dtype) {
 		case BYTE:
@@ -189,7 +189,7 @@ void rubyval_to_cval(VALUE val, dtype_t dtype, void* loc) {
  * Create a RubyObject from a regular C value (given a dtype). Does not return a VALUE! To get a VALUE, you need to
  * look at the rval property of what this function returns.
  */
-nm::RubyObject rubyobj_from_cval(void* val, dtype_t dtype) {
+nm::RubyObject rubyobj_from_cval(void* val, nm::dtype_t dtype) {
   using namespace nm;
 	switch (dtype) {
 		case BYTE:
@@ -238,7 +238,7 @@ nm::RubyObject rubyobj_from_cval(void* val, dtype_t dtype) {
 /*
  * Convert from itype instead of dtype
  */
-nm::RubyObject rubyobj_from_cval_by_itype(void* val, itype_t itype) {
+nm::RubyObject rubyobj_from_cval_by_itype(void* val, nm::itype_t itype) {
   using namespace nm;
 	switch (itype) {
 		case UINT8:
@@ -263,7 +263,7 @@ nm::RubyObject rubyobj_from_cval_by_itype(void* val, itype_t itype) {
  * Allocate and return a piece of data of the correct dtype, converted from a
  * given RubyObject.
  */
-void* rubyobj_to_cval(VALUE val, dtype_t dtype) {
+void* rubyobj_to_cval(VALUE val, nm::dtype_t dtype) {
   size_t size =  DTYPE_SIZES[dtype];
   void* ret_val = ALLOC_N(char, size);
 

data/ext/nmatrix/data/data.h

@@ -82,7 +82,7 @@ namespace nm {
   };
 
 #define STYPE_CAST_COPY_TABLE(name)                                                   \
-  static STORAGE* (*(name)[nm::NUM_STYPES][nm::NUM_STYPES])(const STORAGE*, dtype_t) = {      \
+  static STORAGE* (*(name)[nm::NUM_STYPES][nm::NUM_STYPES])(const STORAGE*, nm::dtype_t) = {      \
     { nm_dense_storage_cast_copy,  nm_dense_storage_from_list,  nm_dense_storage_from_yale },  \
     { nm_list_storage_from_dense,  nm_list_storage_cast_copy,   nm_list_storage_from_yale  },  \
     { nm_yale_storage_from_dense,  nm_yale_storage_from_list,   nm_yale_storage_cast_copy  }   \
@@ -95,6 +95,22 @@ namespace nm {
 #define DTYPE_TEMPLATE_TABLE(fun, ret, ...) NAMED_DTYPE_TEMPLATE_TABLE(ttable, fun, ret, __VA_ARGS__)
 
 #define NAMED_DTYPE_TEMPLATE_TABLE(name, fun, ret, ...) \
+	static ret (*(name)[nm::NUM_DTYPES])(__VA_ARGS__) =	{ \
+		fun<uint8_t>,																				\
+		fun<int8_t>,																				\
+		fun<int16_t>,																				\
+		fun<int32_t>,																				\
+		fun<int64_t>,																				\
+		fun<float32_t>,																			\
+		fun<float64_t>,																			\
+		fun<nm::Complex64>,																  \
+		fun<nm::Complex128>,																\
+		fun<nm::Rational32>,																\
+		fun<nm::Rational64>,																\
+		fun<nm::Rational128> 																\
+	};
+
+#define NAMED_DTYPE_TEMPLATE_TABLE_NO_ROBJ(name, fun, ret, ...) \
 	static ret (*(name)[nm::NUM_DTYPES])(__VA_ARGS__) =	{			\
 		fun<uint8_t>,																				\
 		fun<int8_t>,																				\
@@ -108,7 +124,6 @@ namespace nm {
 		fun<nm::Rational32>,																\
 		fun<nm::Rational64>,																\
 		fun<nm::Rational128>,																\
-		fun<nm::RubyObject>																	\
 	};
 
 /*
@@ -674,6 +689,22 @@ static ret (*(name)[nm::NUM_DTYPES][nm::NUM_DTYPES][nm::NUM_ITYPES])(__VA_ARGS__
 		{ fun<nm::RubyObject,uint8_t>,fun<nm::RubyObject,uint16_t>,fun<nm::RubyObject,uint32_t>,fun<nm::RubyObject,uint64_t>}				\
 	};
 
+	#define NAMED_LI_DTYPE_TEMPLATE_TABLE_NO_ROBJ(name, fun, ret, ...) 																																			\
+  	static ret (*(name)[nm::NUM_DTYPES][nm::NUM_ITYPES])(__VA_ARGS__) = {																																	\
+  		{ fun<uint8_t,uint8_t>,fun<uint8_t,uint16_t>,fun<uint8_t,uint32_t>,fun<uint8_t,uint64_t> },																	\
+  		{ fun<int8_t,uint8_t>,fun<int8_t,uint16_t>,fun<int8_t,uint32_t>,fun<int8_t,uint64_t> },																			\
+  		{ fun<int16_t,uint8_t>,fun<int16_t,uint16_t>,fun<int16_t,uint32_t>,fun<int16_t,uint64_t> },																	\
+  		{ fun<int32_t,uint8_t>,fun<int32_t,uint16_t>,fun<int32_t,uint32_t>,fun<int32_t,uint64_t> },																	\
+  		{ fun<int64_t,uint8_t>,fun<int64_t,uint16_t>,fun<int64_t,uint32_t>,fun<int64_t,uint64_t> },																	\
+  		{ fun<float32_t,uint8_t>,fun<float32_t,uint16_t>,fun<float32_t,uint32_t>,fun<float32_t,uint64_t> },													\
+  		{ fun<float64_t,uint8_t>,fun<float64_t,uint16_t>,fun<float64_t,uint32_t>,fun<float64_t,uint64_t> },													\
+  		{ fun<nm::Complex64,uint8_t>,fun<nm::Complex64,uint16_t>,fun<nm::Complex64,uint32_t>,fun<nm::Complex64,uint64_t> },					\
+  		{ fun<nm::Complex128,uint8_t>,fun<nm::Complex128,uint16_t>,fun<nm::Complex128,uint32_t>,fun<nm::Complex128,uint64_t> },			\
+  		{ fun<nm::Rational32,uint8_t>,fun<nm::Rational32,uint16_t>,fun<nm::Rational32,uint32_t>,fun<nm::Rational32,uint64_t> },			\
+  		{ fun<nm::Rational64,uint8_t>,fun<nm::Rational64,uint16_t>,fun<nm::Rational64,uint32_t>,fun<nm::Rational64,uint64_t> },			\
+  		{ fun<nm::Rational128,uint8_t>,fun<nm::Rational128,uint16_t>,fun<nm::Rational128,uint32_t>,fun<nm::Rational128,uint64_t> }	\
+  	};
+
 
 extern "C" {
 
@@ -690,17 +721,17 @@ extern const size_t 			DTYPE_SIZES[nm::NUM_DTYPES];
 extern const char* const  ITYPE_NAMES[nm::NUM_ITYPES];
 extern const size_t 			ITYPE_SIZES[nm::NUM_ITYPES];
 
-extern const dtype_t      Upcast[nm::NUM_DTYPES][nm::NUM_DTYPES];
+extern const nm::dtype_t Upcast[nm::NUM_DTYPES][nm::NUM_DTYPES];
 
 /*
  * Functions
  */
 
 
-void*	    			rubyobj_to_cval(VALUE val, dtype_t dtype);
-void  		  		rubyval_to_cval(VALUE val, dtype_t dtype, void* loc);
-nm::RubyObject	rubyobj_from_cval(void* val, dtype_t dtype);
-nm::RubyObject  rubyobj_from_cval_by_itype(void* val, itype_t itype);
+void*	    			rubyobj_to_cval(VALUE val, nm::dtype_t dtype);
+void  		  		rubyval_to_cval(VALUE val, nm::dtype_t dtype, void* loc);
+nm::RubyObject	rubyobj_from_cval(void* val, nm::dtype_t dtype);
+nm::RubyObject  rubyobj_from_cval_by_itype(void* val, nm::itype_t itype);
 
 } // end of extern "C" block
 

data/ext/nmatrix/data/rational.h

@@ -304,6 +304,12 @@ class Rational {
 	}
 };
 
+// Negative operator
+template <typename Type, typename = typename std::enable_if<std::is_integral<Type>::value>::type>
+inline Rational<Type> operator-(const Rational<Type>& rhs) {
+  return Rational<Type>(-rhs.n, rhs.d);
+}
+
 ////////////////////////////////
 // Native-Rational Operations //
 ////////////////////////////////
@@ -416,6 +422,13 @@ namespace std {
     if (value.n >= 0) return value;
     return nm::Rational<IntType>(-value.n, value.d);
   }
+
+  template <typename IntType, typename = typename std::enable_if<std::is_integral<IntType>::value>::type>
+  nm::Rational<IntType> sqrt(const nm::Rational<IntType>& value) {
+    nm::Rational<IntType> result(std::sqrt(value.n), std::sqrt(value.d));
+    if (value * value == result)      return result;
+    else                              rb_raise(rb_eArgError, "square root of the given rational is not rational");
+  }
 }
 
 #endif // RATIONAL_H

data/ext/nmatrix/data/ruby_object.h

@@ -319,6 +319,11 @@ class RubyObject {
 	}
 };
 
+// Negative operator
+inline RubyObject operator-(const RubyObject& rhs) {
+  return RubyObject(rb_funcall(rhs.rval, nm_rb_negate, 0));
+}
+
 
 ////////////////////////////
 // NATIVE-RUBY OPERATIONS //
@@ -441,6 +446,11 @@ namespace std {
   inline nm::RubyObject abs(const nm::RubyObject& obj) {
     return obj.abs();
   }
+
+  inline nm::RubyObject sqrt(const nm::RubyObject& obj) {
+    VALUE cMath = rb_const_get(rb_cObject, rb_intern("Math"));
+    return nm::RubyObject(rb_funcall(cMath, rb_intern("sqrt"), 1, obj.rval));
+  }
 }
 
 #endif // RUBY_OBJECT_H