Showing preview only (3,226K chars total). Download the full file or copy to clipboard to get everything.
Repository: SciRuby/nmatrix
Branch: master
Commit: beb266ed1ae5
Files: 285
Total size: 3.0 MB
Directory structure:
gitextract_ehxqtovs/
├── .gitignore
├── .rspec
├── .travis.yml
├── CONTRIBUTING.md
├── Gemfile
├── History.txt
├── LICENSE.txt
├── Manifest.txt
├── README.rdoc
├── Rakefile
├── ext/
│ ├── nmatrix/
│ │ ├── binary_format.txt
│ │ ├── data/
│ │ │ ├── complex.h
│ │ │ ├── data.cpp
│ │ │ ├── data.h
│ │ │ ├── meta.h
│ │ │ └── ruby_object.h
│ │ ├── extconf.rb
│ │ ├── math/
│ │ │ ├── asum.h
│ │ │ ├── cblas_enums.h
│ │ │ ├── cblas_templates_core.h
│ │ │ ├── gemm.h
│ │ │ ├── gemv.h
│ │ │ ├── getrf.h
│ │ │ ├── getrs.h
│ │ │ ├── imax.h
│ │ │ ├── laswp.h
│ │ │ ├── long_dtype.h
│ │ │ ├── magnitude.h
│ │ │ ├── math.h
│ │ │ ├── nrm2.h
│ │ │ ├── rot.h
│ │ │ ├── rotg.h
│ │ │ ├── scal.h
│ │ │ ├── trsm.h
│ │ │ └── util.h
│ │ ├── math.cpp
│ │ ├── nm_memory.h
│ │ ├── nmatrix.cpp
│ │ ├── nmatrix.h
│ │ ├── ruby_constants.cpp
│ │ ├── ruby_constants.h
│ │ ├── ruby_nmatrix.c
│ │ ├── storage/
│ │ │ ├── common.cpp
│ │ │ ├── common.h
│ │ │ ├── dense/
│ │ │ │ ├── dense.cpp
│ │ │ │ └── dense.h
│ │ │ ├── list/
│ │ │ │ ├── list.cpp
│ │ │ │ └── list.h
│ │ │ ├── storage.cpp
│ │ │ ├── storage.h
│ │ │ └── yale/
│ │ │ ├── class.h
│ │ │ ├── iterators/
│ │ │ │ ├── base.h
│ │ │ │ ├── iterator.h
│ │ │ │ ├── row.h
│ │ │ │ ├── row_stored.h
│ │ │ │ ├── row_stored_nd.h
│ │ │ │ └── stored_diagonal.h
│ │ │ ├── math/
│ │ │ │ └── transpose.h
│ │ │ ├── yale.cpp
│ │ │ └── yale.h
│ │ ├── types.h
│ │ └── util/
│ │ ├── io.cpp
│ │ ├── io.h
│ │ ├── sl_list.cpp
│ │ ├── sl_list.h
│ │ └── util.h
│ ├── nmatrix_atlas/
│ │ ├── extconf.rb
│ │ ├── math_atlas/
│ │ │ ├── cblas_templates_atlas.h
│ │ │ ├── clapack_templates.h
│ │ │ ├── geev.h
│ │ │ ├── gesdd.h
│ │ │ ├── gesvd.h
│ │ │ └── inc.h
│ │ ├── math_atlas.cpp
│ │ └── nmatrix_atlas.cpp
│ ├── nmatrix_fftw/
│ │ ├── extconf.rb
│ │ └── nmatrix_fftw.cpp
│ ├── nmatrix_java/
│ │ ├── nmatrix/
│ │ │ ├── math/
│ │ │ │ └── MathHelper.java
│ │ │ ├── storage/
│ │ │ │ └── dense/
│ │ │ │ └── ArrayComparator.java
│ │ │ └── util/
│ │ │ ├── ArrayGenerator.java
│ │ │ ├── MatrixGenerator.java
│ │ │ └── WrapperType.java
│ │ └── test/
│ │ ├── AssertTests.java
│ │ └── TestRunner.java
│ └── nmatrix_lapacke/
│ ├── extconf.rb
│ ├── lapacke/
│ │ ├── include/
│ │ │ ├── lapacke.h
│ │ │ ├── lapacke_config.h
│ │ │ ├── lapacke_mangling.h
│ │ │ ├── lapacke_mangling_with_flags.h
│ │ │ └── lapacke_utils.h
│ │ ├── src/
│ │ │ ├── lapacke_cgeev.c
│ │ │ ├── lapacke_cgeev_work.c
│ │ │ ├── lapacke_cgeqrf.c
│ │ │ ├── lapacke_cgeqrf_work.c
│ │ │ ├── lapacke_cgesdd.c
│ │ │ ├── lapacke_cgesdd_work.c
│ │ │ ├── lapacke_cgesvd.c
│ │ │ ├── lapacke_cgesvd_work.c
│ │ │ ├── lapacke_cgetrf.c
│ │ │ ├── lapacke_cgetrf_work.c
│ │ │ ├── lapacke_cgetri.c
│ │ │ ├── lapacke_cgetri_work.c
│ │ │ ├── lapacke_cgetrs.c
│ │ │ ├── lapacke_cgetrs_work.c
│ │ │ ├── lapacke_cpotrf.c
│ │ │ ├── lapacke_cpotrf_work.c
│ │ │ ├── lapacke_cpotri.c
│ │ │ ├── lapacke_cpotri_work.c
│ │ │ ├── lapacke_cpotrs.c
│ │ │ ├── lapacke_cpotrs_work.c
│ │ │ ├── lapacke_cunmqr.c
│ │ │ ├── lapacke_cunmqr_work.c
│ │ │ ├── lapacke_dgeev.c
│ │ │ ├── lapacke_dgeev_work.c
│ │ │ ├── lapacke_dgeqrf.c
│ │ │ ├── lapacke_dgeqrf_work.c
│ │ │ ├── lapacke_dgesdd.c
│ │ │ ├── lapacke_dgesdd_work.c
│ │ │ ├── lapacke_dgesvd.c
│ │ │ ├── lapacke_dgesvd_work.c
│ │ │ ├── lapacke_dgetrf.c
│ │ │ ├── lapacke_dgetrf_work.c
│ │ │ ├── lapacke_dgetri.c
│ │ │ ├── lapacke_dgetri_work.c
│ │ │ ├── lapacke_dgetrs.c
│ │ │ ├── lapacke_dgetrs_work.c
│ │ │ ├── lapacke_dormqr.c
│ │ │ ├── lapacke_dormqr_work.c
│ │ │ ├── lapacke_dpotrf.c
│ │ │ ├── lapacke_dpotrf_work.c
│ │ │ ├── lapacke_dpotri.c
│ │ │ ├── lapacke_dpotri_work.c
│ │ │ ├── lapacke_dpotrs.c
│ │ │ ├── lapacke_dpotrs_work.c
│ │ │ ├── lapacke_sgeev.c
│ │ │ ├── lapacke_sgeev_work.c
│ │ │ ├── lapacke_sgeqrf.c
│ │ │ ├── lapacke_sgeqrf_work.c
│ │ │ ├── lapacke_sgesdd.c
│ │ │ ├── lapacke_sgesdd_work.c
│ │ │ ├── lapacke_sgesvd.c
│ │ │ ├── lapacke_sgesvd_work.c
│ │ │ ├── lapacke_sgetrf.c
│ │ │ ├── lapacke_sgetrf_work.c
│ │ │ ├── lapacke_sgetri.c
│ │ │ ├── lapacke_sgetri_work.c
│ │ │ ├── lapacke_sgetrs.c
│ │ │ ├── lapacke_sgetrs_work.c
│ │ │ ├── lapacke_sormqr.c
│ │ │ ├── lapacke_sormqr_work.c
│ │ │ ├── lapacke_spotrf.c
│ │ │ ├── lapacke_spotrf_work.c
│ │ │ ├── lapacke_spotri.c
│ │ │ ├── lapacke_spotri_work.c
│ │ │ ├── lapacke_spotrs.c
│ │ │ ├── lapacke_spotrs_work.c
│ │ │ ├── lapacke_zgeev.c
│ │ │ ├── lapacke_zgeev_work.c
│ │ │ ├── lapacke_zgeqrf.c
│ │ │ ├── lapacke_zgeqrf_work.c
│ │ │ ├── lapacke_zgesdd.c
│ │ │ ├── lapacke_zgesdd_work.c
│ │ │ ├── lapacke_zgesvd.c
│ │ │ ├── lapacke_zgesvd_work.c
│ │ │ ├── lapacke_zgetrf.c
│ │ │ ├── lapacke_zgetrf_work.c
│ │ │ ├── lapacke_zgetri.c
│ │ │ ├── lapacke_zgetri_work.c
│ │ │ ├── lapacke_zgetrs.c
│ │ │ ├── lapacke_zgetrs_work.c
│ │ │ ├── lapacke_zpotrf.c
│ │ │ ├── lapacke_zpotrf_work.c
│ │ │ ├── lapacke_zpotri.c
│ │ │ ├── lapacke_zpotri_work.c
│ │ │ ├── lapacke_zpotrs.c
│ │ │ ├── lapacke_zpotrs_work.c
│ │ │ ├── lapacke_zunmqr.c
│ │ │ └── lapacke_zunmqr_work.c
│ │ └── utils/
│ │ ├── lapacke_c_nancheck.c
│ │ ├── lapacke_cge_nancheck.c
│ │ ├── lapacke_cge_trans.c
│ │ ├── lapacke_cpo_nancheck.c
│ │ ├── lapacke_cpo_trans.c
│ │ ├── lapacke_ctr_nancheck.c
│ │ ├── lapacke_ctr_trans.c
│ │ ├── lapacke_d_nancheck.c
│ │ ├── lapacke_dge_nancheck.c
│ │ ├── lapacke_dge_trans.c
│ │ ├── lapacke_dpo_nancheck.c
│ │ ├── lapacke_dpo_trans.c
│ │ ├── lapacke_dtr_nancheck.c
│ │ ├── lapacke_dtr_trans.c
│ │ ├── lapacke_lsame.c
│ │ ├── lapacke_s_nancheck.c
│ │ ├── lapacke_sge_nancheck.c
│ │ ├── lapacke_sge_trans.c
│ │ ├── lapacke_spo_nancheck.c
│ │ ├── lapacke_spo_trans.c
│ │ ├── lapacke_str_nancheck.c
│ │ ├── lapacke_str_trans.c
│ │ ├── lapacke_xerbla.c
│ │ ├── lapacke_z_nancheck.c
│ │ ├── lapacke_zge_nancheck.c
│ │ ├── lapacke_zge_trans.c
│ │ ├── lapacke_zpo_nancheck.c
│ │ ├── lapacke_zpo_trans.c
│ │ ├── lapacke_ztr_nancheck.c
│ │ └── lapacke_ztr_trans.c
│ ├── lapacke.cpp
│ ├── lapacke_nmatrix.h
│ ├── make_lapacke_cpp.rb
│ ├── math_lapacke/
│ │ ├── cblas_local.h
│ │ ├── cblas_templates_lapacke.h
│ │ └── lapacke_templates.h
│ ├── math_lapacke.cpp
│ └── nmatrix_lapacke.cpp
├── lib/
│ ├── nmatrix/
│ │ ├── atlas.rb
│ │ ├── blas.rb
│ │ ├── cruby/
│ │ │ └── math.rb
│ │ ├── enumerate.rb
│ │ ├── fftw.rb
│ │ ├── homogeneous.rb
│ │ ├── io/
│ │ │ ├── fortran_format.rb
│ │ │ ├── harwell_boeing.rb
│ │ │ ├── market.rb
│ │ │ ├── mat5_reader.rb
│ │ │ ├── mat_reader.rb
│ │ │ └── point_cloud.rb
│ │ ├── jruby/
│ │ │ ├── decomposition.rb
│ │ │ ├── enumerable.rb
│ │ │ ├── error.rb
│ │ │ ├── math.rb
│ │ │ ├── nmatrix_java.rb
│ │ │ ├── operators.rb
│ │ │ └── slice.rb
│ │ ├── lapack_core.rb
│ │ ├── lapack_ext_common.rb
│ │ ├── lapack_plugin.rb
│ │ ├── lapacke.rb
│ │ ├── math.rb
│ │ ├── mkmf.rb
│ │ ├── monkeys.rb
│ │ ├── nmatrix.rb
│ │ ├── rspec.rb
│ │ ├── shortcuts.rb
│ │ ├── version.rb
│ │ └── yale_functions.rb
│ └── nmatrix.rb
├── nmatrix-atlas.gemspec
├── nmatrix-fftw.gemspec
├── nmatrix-lapacke.gemspec
├── nmatrix.gemspec
├── scripts/
│ ├── benchmarks/
│ │ └── nmatrix_creation.rb
│ ├── switch_lapack_ubuntu.rb
│ └── ttable_helper.rb
├── spec/
│ ├── 00_nmatrix_spec.rb
│ ├── 01_enum_spec.rb
│ ├── 02_slice_spec.rb
│ ├── 03_nmatrix_monkeys_spec.rb
│ ├── 2x2_dense_double.mat
│ ├── 4x4_sparse.mat
│ ├── 4x5_dense.mat
│ ├── blas_spec.rb
│ ├── elementwise_spec.rb
│ ├── homogeneous_spec.rb
│ ├── io/
│ │ ├── fortran_format_spec.rb
│ │ ├── harwell_boeing_spec.rb
│ │ └── test.rua
│ ├── io_spec.rb
│ ├── lapack_core_spec.rb
│ ├── leakcheck.rb
│ ├── math_spec.rb
│ ├── nmatrix_yale_resize_test_associations.yaml
│ ├── nmatrix_yale_spec.rb
│ ├── plugins/
│ │ ├── atlas/
│ │ │ └── atlas_spec.rb
│ │ ├── fftw/
│ │ │ └── fftw_spec.rb
│ │ └── lapacke/
│ │ └── lapacke_spec.rb
│ ├── rspec_monkeys.rb
│ ├── rspec_spec.rb
│ ├── shortcuts_spec.rb
│ ├── slice_set_spec.rb
│ ├── spec_helper.rb
│ ├── stat_spec.rb
│ └── test.pcd
└── travis.sh
================================================
FILE CONTENTS
================================================
================================================
FILE: .gitignore
================================================
.idea
Gemfile.lock
ext/nmatrix/dense/daxpy.c
ext/nmatrix/dense/dgeco.c
ext/nmatrix/dense/dgefa.c
ext/nmatrix/dense/dgemm.c
ext/nmatrix/dense/dgemv.c
ext/nmatrix/dense/dscal.c
ext/nmatrix/dense/idamax.c
ext/nmatrix/dense/467.c
ext/nmatrix/dense/*.f
ext/nmatrix/dense/transpose.txt
ext/nmatrix/yale/aicm.tex
tmp/
test.c
spec/*.mtx
*.so
*.bundle
*.bundle.dSYM
*.log
*.sw?
*~
/tags
*.gem
html/
doc/
docs/
pkg/
.autotest
ext/nmatrix_java/vendor/
ext/nmatrix_java/target/
ext/nmatrix_java/build/
ext/nmatrix_java/target/
*.class
*.jar
================================================
FILE: .rspec
================================================
--color
--format RSpec::Longrun::Formatter
================================================
FILE: .travis.yml
================================================
language: ruby
sudo: required
cache: bundler
os:
- linux
- osx
osx_image: xcode7.2
env:
- USE_ATLAS=1 # This configuration installs ATLAS, builds and tests the nmatrix, nmatrix-atlas, and nmatrix-lapacke gems
- USE_OPENBLAS=1 # Installs OpenBLAS and reference LAPACK, builds and tests nmatrix, nmatrix-lapacke
- USE_REF=1 # Installs OpenBLAS and reference LAPACK, builds and tests nmatrix, nmatrix-lapacke
- NO_EXTERNAL_LIB=1 # No external libraries installed, only nmatrix
rvm:
- 2.0.0-p648
- 2.1.8
- 2.2.4
- 2.3.0
- 2.4.2
- ruby-head
# The latest stable and head versions built by clang
- 2.3.0-clang
- ruby-head-clang
# JRuby versions --- experimental, pending merging Prasun's GSoC project.
- jruby-9.0.5.0 # earliest supported version (uncomment when jruby-head is passing)
- jruby-head # latest supported JRuby
# Make sure to add exclude lines for new JRuby versions below.
before_install: ./travis.sh before_install
install: ./travis.sh install
script: ./travis.sh script
# Define extra configurations to add to the build matrix.
# The idea here is that the USE_ATLAS=1 option should exercise all the ruby
# code, so it is the only one we need to test with all versions of ruby.
# For other configurations we only test with one version of ruby.
matrix:
exclude:
- rvm: jruby-head
env: USE_ATLAS=1
- rvm: jruby-head
env: USE_OPENBLAS=1
- rvm: jruby-head
env: USE_REF=1
- rvm: jruby-9.0.5.0
env: USE_ATLAS=1
- rvm: jruby-9.0.5.0
env: USE_OPENBLAS=1
- rvm: jruby-9.0.5.0
env: USE_REF=1
# NOTE: The following two ruby versions on OSX are currently unavailable
- os: osx
rvm: 2.0.0-p648
- os: osx
rvm: 2.1.8
- os: osx
rvm: 2.2.4
- os: osx
rvm: 2.3.0
- os: osx
rvm: ruby-head
- os: osx
rvm: 2.3.0-clang
- os: osx
rvm: ruby-head-clang
# FIXME: The following configuration is unavailable because ATLAS should be built from source.
# We need homebrew formula for ATLAS and its bottle.
- os: osx
env: USE_ATLAS=1
# FIXME: The following configuration takes too long time when installing homebrew/dupes/lapack.
# We need the bottle of lapack formula.
- os: osx
env: USE_REF=1
include:
# The latest stable and head versions of ruby built by clang on OSX
- os: osx
compiler: clang
rvm: 2.2
env:
- ruby_version=2.4.0-dev USE_OPENBLAS=1
- os: osx
compiler: clang
rvm: 2.2
env:
- ruby_version=2.4.0-dev NO_EXTERNAL_LIB=1
- os: osx
compiler: clang
rvm: 2.2
env:
- ruby_version=2.3.0 USE_OPENBLAS=1
- os: osx
compiler: clang
rvm: 2.2
env:
- ruby_version=2.3.0 NO_EXTERNAL_LIB=1
# The latest version of Ruby 2.2.x built by clang on OSX
- os: osx
compiler: clang
rvm: 2.2
env:
- ruby_version=2.2.4 USE_OPENBLAS=1
# The latest version of Ruby 2.1.x built by clang on OSX
- os: osx
compiler: clang
rvm: 2.2
env:
- ruby_version=2.1.8 USE_OPENBLAS=1
allow_failures:
# trunk
- rvm: ruby-head
- rvm: ruby-head-clang
- os: osx
compiler: clang
rvm: 2.2
env:
- ruby_version=2.4.0-dev USE_OPENBLAS=1
- os: osx
compiler: clang
rvm: 2.2
env:
- ruby_version=2.4.0-dev NO_EXTERNAL_LIB=1
notifications:
irc: "chat.freenode.net#sciruby"
================================================
FILE: CONTRIBUTING.md
================================================
NMatrix is part of SciRuby, a collaborative effort to bring scientific
computation to Ruby. If you want to help, please do so!
This guide covers ways in which you can contribute to the development
of SciRuby and, more specifically, NMatrix.
## How to help
There are various ways to help NMatrix: bug reports, coding and
documentation. All of them are important.
First, you can help implement new features or bug fixes. To do that,
visit our [roadmap](https://github.com/SciRuby/nmatrix/wiki/Roadmap)
or our [issue tracker][2]. If you find something that you want to work
on, post it in the issue or on our [mailing list][1].
You need to send tests together with your code. No exceptions. You can
ask for our opinion, but we won't accept patches without good spec
coverage.
We use RSpec for testing. If you aren't familiar with it, there's a
good [guide to better specs with RSpec](http://betterspecs.org/) that
shows a bit of the syntax and how to use it properly. However, the
best resource is probably the specs that already exist -- so just read
them.
And don't forget to write documentation (we use rdoc). It's necessary
to allow others to know what's available in the library. There's a
section on it later in this guide.
We only accept bug reports and pull requests in GitHub. You'll need to
create a new (free) account if you don't have one already. To learn
how to create a pull request, please see
[this guide on collaborating](https://help.github.com/categories/63/articles).
If you have a question about how to use NMatrix or SciRuby in general
or a feature/change in mind, please ask the
[sciruby-dev mailing list][1].
Thanks!
## Coding
To start helping with the code, you need to have all the dependencies in place:
- GCC 4.3+
- git
- Ruby 1.9+
- `bundler` gem
- ATLAS/LAPACKE/FFTW dependending on the plugin you want to change.
Now, you need to clone the git repository:
```bash
$ git clone git://github.com/SciRuby/nmatrix.git
$ cd nmatrix
$ bundle install
$ rake compile
$ rake spec
```
This will install all dependencies, compile the extension and run the
specs.
For **JRuby**
```bash
$ mkdir ext/nmatrix_java/vendor
Download commons_math.3.6.1 jar and place it in ext/nmatrix_java/vendor directory
$ mkdir -p ext/nmatrix_java/build/class
$ mkdir ext/nmatrix_java/target
$ rake jruby
```
If everything's fine until now, you can create a new branch to work on
your feature:
```bash
$ git branch new-feature
$ git checkout new-feature
```
Before commiting any code, please read our
[Contributor Agreement](http://github.com/SciRuby/sciruby/wiki/Contributor-Agreement).
### Guidelines for interfacing with C/C++
NMatrix uses a lot of C/C++ to speed up execution of processes and
give more control over data types, storage types, etc. Since we are
interfacing between two very different languages, things can get out
of hand pretty fast.
Please go thorough this before you create any C accessors:
* Perform all pre-computation error checking in Ruby.
* Curate any extra data (cloned objects, trivial computations, etc.) in Ruby.
* Do _NOT_ resolve VALUE into constituent elements unless they reach the function where the elements are needed or it is absolutely necessary. Passing around a VALUE in the C/C++ core is much more convienient than passing around `void*` pointers which point to an array of matrix elements.
Basically, follow a practice of 'once you enter C, never look back!'.
If you have something more in mind, discuss it in the issue tracker or
on
[this](https://groups.google.com/forum/#!topic/sciruby-dev/OJxhrGG309o)
thread.
## C/C++ style guide
This section is a work in progress.
* Use camel_case notation for arguments. No upper case.
* Write a brief description of the arguments that your function
receives in the comments directly above the function.
* Explicitly state in the comments any anomalies that your function
might have. For example, that it does not work with a certain
storage or data type.
## Documentation
There are two ways in which NMatrix is being documented: guides and
comments, which are converted with RDoc into the documentation seen in
[sciruby.com](http://sciruby.com).
If you want to write a guide on how to use NMatrix to solve some
problem or simply showing how to use one of its features, write it as
a wiki page and send an e-mail on the [mailing list][1]. We're working
to improve this process.
If you aren't familiar with RDoc syntax,
[this is the official documentation](http://docs.seattlerb.org/rdoc/RDoc/Markup.html).
## Making new nmatrix extensions
From version 0.2, NMatrix supports extensions, all of which can be
hosted from the main nmatrix repo.
Refer to
[this blog post ](http://wlevine.github.io/2015/06/15/releasing-multiple-gems-with-c-extensions-from-the-same-repository.html)
to see how to do that in case you want to write your own extension for
nmatrix.
## Conclusion
This guide was heavily based on the
[Contributing to Ruby on Rails guide](http://edgeguides.rubyonrails.org/contributing_to_ruby_on_rails.html).
[1]: https://groups.google.com/forum/?fromgroups#!forum/sciruby-dev
[2]: https://github.com/sciruby/nmatrix/issues?sort=created&state=open
================================================
FILE: Gemfile
================================================
source 'https://rubygems.org'
#main gemspec
gemspec :name => 'nmatrix'
#plugin gemspecs
Dir['nmatrix-*.gemspec'].each do |gemspec_file|
plugin_name = gemspec_file.match(/(nmatrix-.*)\.gemspec/)[1]
gemspec(:name => plugin_name, :development_group => :plugin)
end
================================================
FILE: History.txt
================================================
=== 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 <typeinfo> and <vector> 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
=== 0.0.8 / 2013-08-23
* 2 bug fixes:
* Fixed Ubuntu compilation bug caused by math header file
refactoring
* Fixed pry version error which manifests on some systems but not
others
=== 0.0.9 / 2013-09-18
* 5 major enhancements:
* Re-factored NMatrix constructor
* Improved usability of NMatrix shortcut constructor options
(e.g., #zeros, #ones, #random, etc.) using new NMatrix
constructor
* Left-assignment of slices for all matrix storage types (uses a
dense cast, or accepts an array or single value)
* Re-factored Yale into a more object-oriented and less confusing
set of header files
* Enabled Travis CI (by @cjfuller)
* 4 minor enhancements:
* Renamed some specs in order to change their test order, so that
critical tests fail first (particularly in the case of
segmentation faults)
* Default dtype is now :object when no initial values are
specified
* Deprecated NVector#initialize and a number of other unnecessary
NVector functionality
* Made Ubuntu compilation significantly easier (by @cjfuller)
* 2 bug fixes:
* nil values in matrices are now pretty printed as "nil"
* Casting from dense to Yale now properly accepts the default
value option
=== 0.1.0.rc1 / 2013-12-28
* 4 major enhancements:
* Improved garbage collection strategy for partial object creation
(i.e., when VALUEs are allocated but not registered right away),
which in addition to fixing numerous bugs should prevent some new
bugs from arising in the future (by @cjfuller)
* Implemented list storage transpose
* Implemented generic n-dimensional transpose
* Implemented == comparison between differing matrix stypes
* 9 minor enhancements:
* User-friendly #gesvd and #gesdd updates (by @ryanmt)
* Added experimental #yale_row_key_intersection function for expert
recommendation problems
* Added additional *indgen shortcuts and changed behavior for some;
now, #cindgen for :complex64, #zindgen for :complex128, #findgen
for :float32, #dindgen for :float64, #rindgen for :rational128,
and #rbindgen for Ruby objects (which contain integers); also,
removed code repetition
* Changed #stddev to use elementwise #sqrt instead of a manual map
block (by @cjfuller)
* Added alias from MATLAB `load_mat` method to `load` for
consistency with the MatrixMarket loader
* Improved organization by moving list and yale code into storage/
subdirectories
* Added NMatrix#potrf! and NMatrix#getrf, which are instance methods
for calling CLAPACK functions (NMatrix#getrf! already existed)
* Added GCC installation instructions for Mac OS X Mavericks, and
updated the old installation instructions for Mac OS X (both
found in scripts/)
* Switched NMatrix::VERSION to work more like Rails::VERSION, with
support for MAJOR, MINOR, TINY, and PRE
* Added #concat, #hconcat, #vconcat, and #dconcat for joining
matrices together
* 16 bug fixes:
* Spec revisions for lapack_gesdd and lapack_gesvd (by @ryanmt)
* Fixed two double-free problems (by @cjfuller and @mohawkjohn)
* Fixed contiguous array marking fencepost error
* Fixed C/C++ API compatibility problem preventing rb/gsl linking
* Resolved a number of compiler warnings, including one return-type
problem that would likely have become a garbage collection error
(if it wasn't already)
* Fixed -O3 optimization problems
* Restored NMatrix#asum, #nrm2, #binned_sorted_indices,
#sorted_indices which were inadvertantly removed by NVector
deprecation; have not tested
* Experimental #yale_nd_row and functions which call it now checks
range of argument to prevent segfault
* Fixed :* shortcut for a full list dimension (by @cjfuller)
* Fixed list construction problem which occurred when an initial
value array was provided (by @cjfuller)
* Fixed #inject issue with list and yale matrices of two dimensions
(by @cjfuller)
* Fixed several garbage collection problems (also listed under
enhancements) (by @cjfuller)
* Updated object cleaning target in extconf.rb
* Fixed possible compilation problem on Mavericks with Xcode 5.02
* Fixed errors involving undefined symbols, unresolved symbols, and
lazy symbol binding
* Improved LAPACK and BLAS header selection for Ubuntu/Debian
systems with ATLAS (by @mvz)
=== 0.1.0.rc2 / 2014-03-12
* No major enhancements.
* 14 minor enhancements:
* Implemented negative-index slicing (by @rajatkapoor)
* Added reader for Point Cloud Library's PCD format
* Added Ruby 2.1 support (including Travis CI testing)
* Implemented LAPACK-independent exact inverse calculation for
dense matrices of size 2x2 and 3x3, as well as
* Added NMatrix::has_clapack? method to determine whether CLAPACK
support has been compiled in
* Improved conformance of specs to RSpec best practices (by
@duggiefresh)
* Travis CI now updates the IRC channel when a check passes (by
@agarie)
* Added NMatrix#data_pointer, which returns the memory address of
the stored elements in a matrix (generally for use with FFI and
other libraries that need pointers)
* Made NMatrix#clone_structure a public method (was protected)
* Added :scale option for NMatrix::random to handle non-floating
point forms
* Added complex support to NMatrix::random
* Aliased NMatrix::random to NMatrix::rand
* Added NMatrix#reshape! for in-place reshape of dense matrices (by
@rajatkapoor)
* Implemented unary negation of matrices
* 6 bug fixes:
* Fixed dot product operation on 1-dimensional matrices (by @rve
and @cjfuller)
* Fixed segfault on 1-dimensional matrix transpose (by @cjfuller)
* Fixed compile error with Ruby 2.1 (by @diminish7)
* Fixed regression which wasn't causing any problems but was
counter to design: stride was declared prior to data storage for
dense matrix storage
* Fixed Rakefile problem which was causing specs to run twice in a
row with each call to rake spec
* NMatrix::random now raises an exception when rational matrices
are requested
=== 0.1.0.rc3 / 2014-03-27
* No major enhancements.
* 2 minor enhancements:
* Exposed NMatrix::LAPACK::geev for LAPACK's xGEEV
* Added out-of-place complex conjugate for dense and yale storage
(by @rve)
* 1 bug fixes:
* Fixed critical bug with transposing a matrix reference slice (by
@rajatkapoor)
=== 0.1.0.rc4 / 2014-07-24
* No major enhancements.
* 1 minor enhancement:
* NMatrix#floor and #ceil implemented (by @v0dro)
* 2 bug fixes:
* Disallowed out-of-bounds rank calls (by @andrewcsmith)
* Fixed rspec 3.0 conflict with rspec-longrun 1.0.1
=== 0.1.0.rc5 / 2014-08-01
* No major enhancements.
* 1 minor enhancements:
* Added optional extension for generating homogeneous
transformation matrices for rotations and translations in three
dimensions
* 3 bug fixes:
* Fixed rake install (by @duggiefresh)
* Fixed API problems which prevented NMatrix from working with
the SciRuby rb-gsl fork
* Fixed Yale #inject behavior (by @yoongkang)
=== 0.1.0 / 2014-12-11
* 3 major enhancements:
* Updated to BSD 3-clause license
* Removed Ruby 1.9.2 support; now requires Ruby 1.9.3 or
higher (by @v0dro)
* Added Gauss-Jordan elimination for calculation of
matrix inverses (by @v0dro)
* 6 minor enhancements:
* Added trace method for square matrices
* Improved Array#to_nm monkey patch so matrices and
arrays can be interconverted easily, without need for a
shape argument (by @andrewcsmith)
* Added Harwell-Boeing and Fortran matrix format parsers
(by @v0dro)
* Removed soon-to-be-deprecated autoloads and replaced
with a more robust method (by @duggiefresh)
* Updated rake install task to use Bundler's GemHelper
install task (by @duggiefresh)
* Moved packable requirement from Gemfile to gemspec
(by @andrewcsmith)
* 3 bug fixes:
* Corrected Ubuntu clapack functionality checking, which
should fix most functions which rely on the ATLAS
version of clapack
* Corrected NMatrix::gesdd workspace request size (by
@yoongkang)
* Fixed definition of NMatrix#asum for one-by-one
matrices (by @andrewcsmith)
=== 0.2.0 / 2015-08-24
* 2 major enhancements:
* External libraries are now linked via optional plugins,
removing ATLAS dependencies (by @wlevine)
* Made it possible to use NMatrix together with NArray (by
@blackwinter)
* 9 minor enhancements:
* Removed rational types (by @wlevine)
* Added block-diagonal matrix generation method,
NMatrix.block_diagonal (by @agisga)
* Added Kronecker product method #kron_prod (by @agisga)
* Made #permute_columns usage more intuitive (@agisga)
* Added #pow method to raise a matrix to an integer power
(by @v0dro)
* Added #meshgrid method (by @dilcom)
* Added #hessenberg method, for reducing matrices to upper
Hessenberg form (by @v0dro)
* Added calculation of correlation matrix with #corr and
covariance using #cov (by @v0dro)
* Added method for returning matrix diagonal, #diagonal
(by @v0dro)
* 11 bug fixes:
* Fixed #== operator problems (by @wlevine)
* Fixed BLAS.gemv (by @wlevine)
* Fixed #asum for single element complex matrices (by
@wlevine)
* Fixed determinant calculation (by @wlevine)
* Fixed division by zero (by @spacewander)
* Fixed NMatrix#respond_to? so it would accept two
arguments properly (by @ktns)
* Fixed NMatrix#hermitian? (by @agisga)
* Fixed #gesdd, #gesvd (by @wlevine)
* Fixed #symmetric? (by @ktns)
* Made rdoc a development dependency to resolve dependency
conflicts (by @matt-liu)
* Fixed bug where Array#to_nm would alter the array (by
@andrewcsmith)
=== 0.2.1 / 2016-01-18
* 3 major enhancements:
* New plugin nmatrix-fftw for wrapping over FFTW (by
@v0dro)
* Change Ruby Array C pointer references to be compatible
with Ruby 2.3.0 (by @mrkn)
* NMatrix can now be compiled with clang (by @mrkn)
* 4 minor enhancements:
* Improved Travis configs to test on Linux and OSX with
and without plugins (by @mrkn)
* Added non-abbreviated versions to the options of
NMatrix#solve; added more docs (by @agisga)
* Added several specialized algorithms to NMatrix#solve
for more efficient solving of linear systems with upper
or lower triangular matrices (by @agisga)
* Remove redundant C implementation of
NMatrix#complex_conjugate (by @yoongkang)
* 4 bug fixes:
* Fixed memory leak in math.cpp (inverse()) (by @lokeshh)
* Check if optional permute parameter in NMatrix#transpose
is an Array to prevent unexpected disappearing-parameter
behavior (by @firemind)
* Moved rubyobj_from_cval function into `nm` namespace
from C-linkage to fix a C compile time error (by @mrkn)
* Fixed undefined variable 'idefaults' in lapacke extconf
(by @agisga)
=== 0.2.2 / 2016-07-22
* No major enhancements.
* 15 minor enhancements:
* Added Hilbert and inverse Hilbert matrix functions
#hilbert and #inv_hilbert (by @arafatk)
* Added NMatrix.linspace constructor for generating a
vector with linearly spaced elements (by @gau27)
* Added NMatrix.logspace constructor for generating a
vector with logarithmically spaced elements (by @gau27)
* Improved Travis configs (by @v0dro)
* Added C API documentation and included ruby_constants.h
in C API include files (by @v0dro)
* Added #magic function to create magic square matrices
(by @shahsaurabh0605)
* Added NMatrix#last (by @gau27)
* Added QR factorization by exposing LAPACK functions
GEQRF, ORMQR, UNMQR (by @gau27)
* Made templates a little smarter for those functions
which require a separate return dtype by adding the
MagnitudeDType template typename; and added a magnitude
function to replace std::abs and abs to make complex
and real templates more generic (by @mohawkjohn)
* Added #adjugate and #adjugate! functions (by @sujithvm)
* Added #scale and #scale! methods by exposing BLAS SCAL
(by @lds56)
* Re-factored type comparisons to use RB_TYPE_P instead of
TYPE(obj) (by @mrkn)
* Updated license to BSD 3-clause (by @gau27)
* Cleaned up gem installation settings and dependencies
(by @mrkn)
* DRYed up extconf script (by @mrkn)
* 15 bug fixes:
* Fixed offsets and changed limits in TRSM to follow the
Fortran implementation (by @lokeshh), and adjusted
triangular #solve accordingly (by @agisga)
* Fixed NRM2 (CBLAS 2-norm) for complex types (by
@lokeshh)
* Fixed NRM2 divide-by-zero bug (by @arafatk)
* Fixed #reshape! to work when changing dimensionality (by
@wlevine)
* Fixed ambiguous references by making proper use of
namespace qualifiers for dtypes, allowing compilation in
Windows using the mingw64 toolchain available through
msys2 (by @preetpalS)
* Replaced all uses of u_int8_t with uint8_t and added static
assertions to prevent ambiguous use of u_intX_t types
(by @preetpalS)
* Added workaround in extconf script for Windows use of a
different name for the null device (by @preetpalS)
* Updated deprecated RSpec code and other miscellaneous
cleanups (by @yui-knk)
* Removed incomplete support of Hash as an argument for
NMatrix#[] (by @yui-knk)
* Fixed typo in slicing exception error message (by
@mohawkjohn)
* Fixed #concat implementation for case of differing
sizes along concatenation dimension (by @alno)
* Ensured dtype is preserved by #repeat (by @alno)
* Fixed #det_exact for :object dtype (by @isuruf)
* Stopped using deprecated register storage class
specifier (by @mrkn)
* Fixed clang/clang++ compiler selection by forcing use of
clang++ when clang is used (by @mrkn)
=== 0.2.3 / 2016-07-25
* No major enhancements.
* No minor enhancements.
* 1 bug fix:
* Fixed gem installation problem caused by mkmf
abstraction (by @mrkn)
=== 0.2.4 / 2017-12-14
* No major enhancements.
* 2 minor enhancements:
* Eliminated code reuse in math.rb between JRuby and MRI
versions of library (by @prasunanand)
* Slightly simplified #positive_definite? (by
@prasunanand)
* 2 bug fixes:
* Fixed compilation problem on Mac OS X High Sierra (by
@mohawkjohn)
* Fixed failing #block_diagonal spec (due to missing
Array#sum) (by @mohawkjohn)
================================================
FILE: LICENSE.txt
================================================
This version of NMatrix is licensed under the BSD 3-clause license.
* http://sciruby.com
* http://github.com/sciruby/sciruby/wiki/License
You *must* read the Contributor Agreement before contributing code to the SciRuby Project. This is available online:
* http://github.com/sciruby/sciruby/wiki/Contributor-Agreement
-----
Copyright (c) 2010 - 2015, John Woods and the Ruby Science Foundation
All rights reserved.
Redistribution and use in source and binary forms, with or without modification, are permitted provided that the following conditions are met:
* Redistributions of source code must retain the above copyright notice, this list of conditions and the following disclaimer.
* Redistributions in binary form must reproduce the above copyright notice, this list of conditions and the following disclaimer in the documentation and/or other materials provided with the distribution.
* Neither the name of the copyright holder nor the names of its contributors may be used to endorse or promote products derived from this software without specific prior written permission.
THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
================================================
FILE: Manifest.txt
================================================
History.txt
Manifest.txt
README.rdoc
LICENSE.txt
CONTRIBUTING.md
Rakefile
Gemfile
nmatrix.gemspec
nmatrix-atlas.gemspec
nmatrix-lapacke.gemspec
nmatrix-fftw.gemspec
travis.sh
.travis.yml
lib/nmatrix.rb
lib/nmatrix/atlas.rb
lib/nmatrix/blas.rb
lib/nmatrix/enumerate.rb
lib/nmatrix/homogeneous.rb
lib/nmatrix/math.rb
lib/nmatrix/mkmf.rb
lib/nmatrix/monkeys.rb
lib/nmatrix/nmatrix.rb
lib/nmatrix/shortcuts.rb
lib/nmatrix/version.rb
lib/nmatrix/yale_functions.rb
lib/nmatrix/fftw.rb
lib/nmatrix/lapack_core.rb
lib/nmatrix/lapack_ext_common.rb
lib/nmatrix/lapack_plugin.rb
lib/nmatrix/lapacke.rb
lib/nmatrix/rspec.rb
lib/nmatrix/io/market.rb
lib/nmatrix/io/mat5_reader.rb
lib/nmatrix/io/mat_reader.rb
lib/nmatrix/io/point_cloud.rb
lib/nmatrix/io/fortran_format.rb
lib/nmatrix/io/harwell_boeing.rb
lib/nmatrix/cruby/math.rb
lib/nmatrix/jruby/decomposition.rb
lib/nmatrix/jruby/enumerable.rb
lib/nmatrix/jruby/error.rb
lib/nmatrix/jruby/math.rb
lib/nmatrix/jruby/nmatrix_java.rb
lib/nmatrix/jruby/operators.rb
lib/nmatrix/jruby/slice.rb
ext/nmatrix/math/cblas_enums.h
ext/nmatrix/math/cblas_templates_core.h
ext/nmatrix/math/util.h
ext/nmatrix/math/magnitude.h
ext/nmatrix_atlas/extconf.rb
ext/nmatrix_atlas/math_atlas.cpp
ext/nmatrix_atlas/math_atlas/cblas_templates_atlas.h
ext/nmatrix_atlas/math_atlas/clapack_templates.h
ext/nmatrix_atlas/math_atlas/geev.h
ext/nmatrix_atlas/math_atlas/gesdd.h
ext/nmatrix_atlas/math_atlas/gesvd.h
ext/nmatrix_atlas/math_atlas/inc.h
ext/nmatrix_atlas/nmatrix_atlas.cpp
ext/nmatrix_java/nmatrix/data/Complex.java
ext/nmatrix_java/nmatrix/math/MathHelper.java
ext/nmatrix_java/nmatrix/storage/dense/ArrayComparator.java
ext/nmatrix_java/nmatrix/util/ArrayGenerator.java
ext/nmatrix_java/nmatrix/util/MatrixGenerator.java
ext/nmatrix_java/nmatrix/util/WrapperType.java
ext/nmatrix_java/test/AssertTests.java
ext/nmatrix_java/test/TestRunner.java
ext/nmatrix_lapacke/extconf.rb
ext/nmatrix_lapacke/lapacke.cpp
ext/nmatrix_lapacke/lapacke/include/lapacke.h
ext/nmatrix_lapacke/lapacke/include/lapacke_config.h
ext/nmatrix_lapacke/lapacke/include/lapacke_mangling.h
ext/nmatrix_lapacke/lapacke/include/lapacke_mangling_with_flags.h
ext/nmatrix_lapacke/lapacke/include/lapacke_utils.h
ext/nmatrix_lapacke/lapacke/src/lapacke_cgeev.c
ext/nmatrix_lapacke/lapacke/src/lapacke_cgeev_work.c
ext/nmatrix_lapacke/lapacke/src/lapacke_cgesdd.c
ext/nmatrix_lapacke/lapacke/src/lapacke_cgesdd_work.c
ext/nmatrix_lapacke/lapacke/src/lapacke_cgesvd.c
ext/nmatrix_lapacke/lapacke/src/lapacke_cgesvd_work.c
ext/nmatrix_lapacke/lapacke/src/lapacke_cgetrf.c
ext/nmatrix_lapacke/lapacke/src/lapacke_cgetrf_work.c
ext/nmatrix_lapacke/lapacke/src/lapacke_cgetri.c
ext/nmatrix_lapacke/lapacke/src/lapacke_cgetri_work.c
ext/nmatrix_lapacke/lapacke/src/lapacke_cgetrs.c
ext/nmatrix_lapacke/lapacke/src/lapacke_cgetrs_work.c
ext/nmatrix_lapacke/lapacke/src/lapacke_cpotrf.c
ext/nmatrix_lapacke/lapacke/src/lapacke_cpotrf_work.c
ext/nmatrix_lapacke/lapacke/src/lapacke_cpotri.c
ext/nmatrix_lapacke/lapacke/src/lapacke_cpotri_work.c
ext/nmatrix_lapacke/lapacke/src/lapacke_cpotrs.c
ext/nmatrix_lapacke/lapacke/src/lapacke_cpotrs_work.c
ext/nmatrix_lapacke/lapacke/src/lapacke_dgeev.c
ext/nmatrix_lapacke/lapacke/src/lapacke_dgeev_work.c
ext/nmatrix_lapacke/lapacke/src/lapacke_dgesdd.c
ext/nmatrix_lapacke/lapacke/src/lapacke_dgesdd_work.c
ext/nmatrix_lapacke/lapacke/src/lapacke_dgesvd.c
ext/nmatrix_lapacke/lapacke/src/lapacke_dgesvd_work.c
ext/nmatrix_lapacke/lapacke/src/lapacke_dgetrf.c
ext/nmatrix_lapacke/lapacke/src/lapacke_dgetrf_work.c
ext/nmatrix_lapacke/lapacke/src/lapacke_dgetri.c
ext/nmatrix_lapacke/lapacke/src/lapacke_dgetri_work.c
ext/nmatrix_lapacke/lapacke/src/lapacke_dgetrs.c
ext/nmatrix_lapacke/lapacke/src/lapacke_dgetrs_work.c
ext/nmatrix_lapacke/lapacke/src/lapacke_dpotrf.c
ext/nmatrix_lapacke/lapacke/src/lapacke_dpotrf_work.c
ext/nmatrix_lapacke/lapacke/src/lapacke_dpotri.c
ext/nmatrix_lapacke/lapacke/src/lapacke_dpotri_work.c
ext/nmatrix_lapacke/lapacke/src/lapacke_dpotrs.c
ext/nmatrix_lapacke/lapacke/src/lapacke_dpotrs_work.c
ext/nmatrix_lapacke/lapacke/src/lapacke_sgeev.c
ext/nmatrix_lapacke/lapacke/src/lapacke_sgeev_work.c
ext/nmatrix_lapacke/lapacke/src/lapacke_sgesdd.c
ext/nmatrix_lapacke/lapacke/src/lapacke_sgesdd_work.c
ext/nmatrix_lapacke/lapacke/src/lapacke_sgesvd.c
ext/nmatrix_lapacke/lapacke/src/lapacke_sgesvd_work.c
ext/nmatrix_lapacke/lapacke/src/lapacke_sgetrf.c
ext/nmatrix_lapacke/lapacke/src/lapacke_sgetrf_work.c
ext/nmatrix_lapacke/lapacke/src/lapacke_sgetri.c
ext/nmatrix_lapacke/lapacke/src/lapacke_sgetri_work.c
ext/nmatrix_lapacke/lapacke/src/lapacke_sgetrs.c
ext/nmatrix_lapacke/lapacke/src/lapacke_sgetrs_work.c
ext/nmatrix_lapacke/lapacke/src/lapacke_spotrf.c
ext/nmatrix_lapacke/lapacke/src/lapacke_spotrf_work.c
ext/nmatrix_lapacke/lapacke/src/lapacke_spotri.c
ext/nmatrix_lapacke/lapacke/src/lapacke_spotri_work.c
ext/nmatrix_lapacke/lapacke/src/lapacke_spotrs.c
ext/nmatrix_lapacke/lapacke/src/lapacke_spotrs_work.c
ext/nmatrix_lapacke/lapacke/src/lapacke_zgeev.c
ext/nmatrix_lapacke/lapacke/src/lapacke_zgeev_work.c
ext/nmatrix_lapacke/lapacke/src/lapacke_zgesdd.c
ext/nmatrix_lapacke/lapacke/src/lapacke_zgesdd_work.c
ext/nmatrix_lapacke/lapacke/src/lapacke_zgesvd.c
ext/nmatrix_lapacke/lapacke/src/lapacke_zgesvd_work.c
ext/nmatrix_lapacke/lapacke/src/lapacke_zgetrf.c
ext/nmatrix_lapacke/lapacke/src/lapacke_zgetrf_work.c
ext/nmatrix_lapacke/lapacke/src/lapacke_zgetri.c
ext/nmatrix_lapacke/lapacke/src/lapacke_zgetri_work.c
ext/nmatrix_lapacke/lapacke/src/lapacke_zgetrs.c
ext/nmatrix_lapacke/lapacke/src/lapacke_zgetrs_work.c
ext/nmatrix_lapacke/lapacke/src/lapacke_zpotrf.c
ext/nmatrix_lapacke/lapacke/src/lapacke_zpotrf_work.c
ext/nmatrix_lapacke/lapacke/src/lapacke_zpotri.c
ext/nmatrix_lapacke/lapacke/src/lapacke_zpotri_work.c
ext/nmatrix_lapacke/lapacke/src/lapacke_zpotrs.c
ext/nmatrix_lapacke/lapacke/src/lapacke_zpotrs_work.c
ext/nmatrix_lapacke/lapacke/src/lapacke_cgeqrf.c
ext/nmatrix_lapacke/lapacke/src/lapacke_cgeqrf_work.c
ext/nmatrix_lapacke/lapacke/src/lapacke_cunmqr.c
ext/nmatrix_lapacke/lapacke/src/lapacke_cunmqr_work.c
ext/nmatrix_lapacke/lapacke/src/lapacke_dgeqrf.c
ext/nmatrix_lapacke/lapacke/src/lapacke_dgeqrf_work.c
ext/nmatrix_lapacke/lapacke/src/lapacke_dormqr.c
ext/nmatrix_lapacke/lapacke/src/lapacke_dormqr_work.c
ext/nmatrix_lapacke/lapacke/src/lapacke_sgeqrf.c
ext/nmatrix_lapacke/lapacke/src/lapacke_sgeqrf_work.c
ext/nmatrix_lapacke/lapacke/src/lapacke_sormqr.c
ext/nmatrix_lapacke/lapacke/src/lapacke_sormqr_work.c
ext/nmatrix_lapacke/lapacke/src/lapacke_zgeqrf.c
ext/nmatrix_lapacke/lapacke/src/lapacke_zgeqrf_work.c
ext/nmatrix_lapacke/lapacke/src/lapacke_zunmqr.c
ext/nmatrix_lapacke/lapacke/src/lapacke_zunmqr_work.c
ext/nmatrix_lapacke/lapacke/utils/lapacke_c_nancheck.c
ext/nmatrix_lapacke/lapacke/utils/lapacke_d_nancheck.c
ext/nmatrix_lapacke/lapacke/utils/lapacke_s_nancheck.c
ext/nmatrix_lapacke/lapacke/utils/lapacke_z_nancheck.c
ext/nmatrix_lapacke/lapacke/utils/lapacke_cge_nancheck.c
ext/nmatrix_lapacke/lapacke/utils/lapacke_cge_trans.c
ext/nmatrix_lapacke/lapacke/utils/lapacke_cpo_nancheck.c
ext/nmatrix_lapacke/lapacke/utils/lapacke_cpo_trans.c
ext/nmatrix_lapacke/lapacke/utils/lapacke_ctr_nancheck.c
ext/nmatrix_lapacke/lapacke/utils/lapacke_ctr_trans.c
ext/nmatrix_lapacke/lapacke/utils/lapacke_dge_nancheck.c
ext/nmatrix_lapacke/lapacke/utils/lapacke_dge_trans.c
ext/nmatrix_lapacke/lapacke/utils/lapacke_dpo_nancheck.c
ext/nmatrix_lapacke/lapacke/utils/lapacke_dpo_trans.c
ext/nmatrix_lapacke/lapacke/utils/lapacke_dtr_nancheck.c
ext/nmatrix_lapacke/lapacke/utils/lapacke_dtr_trans.c
ext/nmatrix_lapacke/lapacke/utils/lapacke_lsame.c
ext/nmatrix_lapacke/lapacke/utils/lapacke_sge_nancheck.c
ext/nmatrix_lapacke/lapacke/utils/lapacke_sge_trans.c
ext/nmatrix_lapacke/lapacke/utils/lapacke_spo_nancheck.c
ext/nmatrix_lapacke/lapacke/utils/lapacke_spo_trans.c
ext/nmatrix_lapacke/lapacke/utils/lapacke_str_nancheck.c
ext/nmatrix_lapacke/lapacke/utils/lapacke_str_trans.c
ext/nmatrix_lapacke/lapacke/utils/lapacke_xerbla.c
ext/nmatrix_lapacke/lapacke/utils/lapacke_zge_nancheck.c
ext/nmatrix_lapacke/lapacke/utils/lapacke_zge_trans.c
ext/nmatrix_lapacke/lapacke/utils/lapacke_zpo_nancheck.c
ext/nmatrix_lapacke/lapacke/utils/lapacke_zpo_trans.c
ext/nmatrix_lapacke/lapacke/utils/lapacke_ztr_nancheck.c
ext/nmatrix_lapacke/lapacke/utils/lapacke_ztr_trans.c
ext/nmatrix_lapacke/lapacke_nmatrix.h
ext/nmatrix_lapacke/make_lapacke_cpp.rb
ext/nmatrix_lapacke/math_lapacke.cpp
ext/nmatrix_lapacke/math_lapacke/cblas_local.h
ext/nmatrix_lapacke/math_lapacke/cblas_templates_lapacke.h
ext/nmatrix_lapacke/math_lapacke/lapacke_templates.h
ext/nmatrix_lapacke/nmatrix_lapacke.cpp
ext/nmatrix/data/complex.h
ext/nmatrix/data/data.cpp
ext/nmatrix/data/data.h
ext/nmatrix/data/meta.h
ext/nmatrix/data/ruby_object.h
ext/nmatrix/storage/common.cpp
ext/nmatrix/storage/common.h
ext/nmatrix/storage/storage.cpp
ext/nmatrix/storage/storage.h
ext/nmatrix/storage/dense/dense.cpp
ext/nmatrix/storage/dense/dense.h
ext/nmatrix/storage/list/list.cpp
ext/nmatrix/storage/list/list.h
ext/nmatrix/storage/yale/yale.cpp
ext/nmatrix/storage/yale/yale.h
ext/nmatrix/storage/yale/class.h
ext/nmatrix/storage/yale/iterators/base.h
ext/nmatrix/storage/yale/iterators/iterator.h
ext/nmatrix/storage/yale/iterators/row.h
ext/nmatrix/storage/yale/iterators/row_stored.h
ext/nmatrix/storage/yale/iterators/row_stored_nd.h
ext/nmatrix/storage/yale/iterators/stored_diagonal.h
ext/nmatrix/storage/yale/math/transpose.h
ext/nmatrix/util/io.cpp
ext/nmatrix/util/io.h
ext/nmatrix/util/sl_list.cpp
ext/nmatrix/util/sl_list.h
ext/nmatrix/util/util.h
ext/nmatrix/math.cpp
ext/nmatrix/math/asum.h
ext/nmatrix/math/gemm.h
ext/nmatrix/math/gemv.h
ext/nmatrix/math/getrf.h
ext/nmatrix/math/getrs.h
ext/nmatrix/math/imax.h
ext/nmatrix/math/laswp.h
ext/nmatrix/math/long_dtype.h
ext/nmatrix/math/math.h
ext/nmatrix/math/nrm2.h
ext/nmatrix/math/rot.h
ext/nmatrix/math/rotg.h
ext/nmatrix/math/scal.h
ext/nmatrix/math/trsm.h
ext/nmatrix/nmatrix.cpp
ext/nmatrix/nmatrix.h
ext/nmatrix/ruby_constants.cpp
ext/nmatrix/ruby_constants.h
ext/nmatrix/ruby_nmatrix.c
ext/nmatrix/types.h
ext/nmatrix/nm_memory.h
ext/nmatrix/extconf.rb
ext/nmatrix_fftw/extconf.rb
ext/nmatrix_fftw/nmatrix_fftw.cpp
================================================
FILE: README.rdoc
================================================
= NMatrix
{<img src="https://badges.gitter.im/SciRuby/nmatrix.svg" alt="Join the chat at https://gitter.im/SciRuby/nmatrix">}[https://gitter.im/SciRuby/nmatrix?utm_source=badge&utm_medium=badge&utm_campaign=pr-badge&utm_content=badge]
Fast Numerical Linear Algebra Library for Ruby
* {sciruby.com}[http://sciruby.com]
* {Google+}[https://plus.google.com/109304769076178160953/posts]
* {Google Group - Mailing List}[https://groups.google.com/forum/#!forum/sciruby-dev]
* {NMatrix Installation wiki}[https://github.com/SciRuby/nmatrix/wiki/Installation]
* {SciRuby Installation guide}[http://sciruby.com/docs#installation]
{<img src=https://travis-ci.org/SciRuby/nmatrix.png>}[https://travis-ci.org/SciRuby/nmatrix]
{<img src="https://codeclimate.com/github/SciRuby/nmatrix.png" />}[https://codeclimate.com/github/SciRuby/nmatrix]
== Description
NMatrix is a fast numerical linear algebra library for Ruby, with
dense and sparse matrices, written mostly in C and C++ (and with
experimental JRuby support). It is part of the SciRuby project.
NMatrix was inspired by {NArray}[http://narray.rubyforge.org], by Masahiro Tanaka.
Several gems are provided in this repository:
* +nmatrix+
* +nmatrix-java+
* +nmatrix-atlas+
* +nmatrix-lapacke+
* +nmatrix-fftw+
== Installation
To install the latest stable version:
gem install nmatrix
NMatrix was originally written in C/C++, but an experimental JRuby version is also included (see instructions below for JRuby). For the MRI (C/C++) version, you need:
* Ruby 2.0 or later
* a compiler supporting C++11 (clang or GCC)
To install the +nmatrix-atlas+ or +nmatrix-lapacke+ extensions, an additional requirement is a
compatible LAPACK library.
Detailed directions for this step can be found
{here}[https://github.com/SciRuby/nmatrix/wiki/Installation].
If you want to obtain the latest (development) code, you should generally do:
git clone https://github.com/SciRuby/nmatrix.git
cd nmatrix/
gem install bundler
bundle install
bundle exec rake compile
bundle exec rake spec
If you want to try out the code without installing:
bundle exec rake pry
To install:
bundle exec rake install
=== JRuby
First, you need to download Apache Commons Math 3.6.1 (the JAR, which
you can find in the binary package). For example, in the NMatrix
directory, do:
wget https://www.apache.org/dist/commons/math/binaries/commons-math3-3.6.1-bin.tar.gz
tar zxvf commons-math3-3.6.1-bin.tar.gz
mkdir ext/nmatrix_java/vendor/
cp commons-math3-3.6.1/commons-math3-3.6.1.jar ext/nmatrix_java/vendor/
Next, create build directories:
mkdir -p ext/nmatrix_java/build/class
mkdir ext/nmatrix_java/target
Finally, compile and package as jar.
rake jruby
=== Plugins
The commands above build and install only the core +nmatrix+ gem. If
you want to build one or more of the plugin gems (+nmatrix-atlas+,
+nmatrix-lapacke+) in addition to the core nmatrix gem, use the
<tt>nmatrix_plugins=</tt> option, e.g. <tt>rake compile
nmatrix_plugins=all</tt>, <tt>rake install nmatrix_plugins=atlas</tt>,
<tt>rake clean nmatrix_plugins=atlas,lapacke</tt>. Each of these
commands apply to the +nmatrix+ gem and any additional plugin gems
specified. For example, <tt>rake spec nmatrix_plugins=atlas</tt> will
test both the core +nmatrix+ gem and the +nmatrix-atlas+ gem.
=== Upgrading from NMatrix 0.1.0
If your code requires features provided by ATLAS (Cholesky
decomposition, singular value decomposition, eigenvalues/eigenvectors,
inverses of matrices bigger than 3-by-3), your code now depends on the
+nmatrix-atlas+ gem. You will need to add this a dependency of your
project and <tt>require 'nmatrix/atlas'</tt> in addition to
<tt>require 'nmatrix'</tt>. In most cases, no further changes should
be necessary, however there have been a few {API
changes}[https://github.com/SciRuby/nmatrix/wiki/API-Changes], please
check to see if these affect you.
== Documentation
If you have a suggestion or want to add documentation for any class or
method in NMatrix, please open an issue or send a pull request with
the changes.
You can find the complete API documentation {on our
website}[http://sciruby.com/nmatrix/docs/].
== Examples
Create a new NMatrix from a ruby Array:
>> require 'nmatrix'
>> NMatrix.new([2, 3], [0, 1, 2, 3, 4, 5], dtype: :int64)
=> [
[0, 1, 2],
[3, 4, 5]
]
Create a new NMatrix using the +N+ shortcut:
>> m = N[ [2, 3, 4], [7, 8, 9] ]
=> [
[2, 3, 4],
[7, 8, 9]
]
>> m.inspect
=> #<NMatrix:0x007f8e121b6cf8shape:[2,3] dtype:int32 stype:dense>
The above output requires that you have a pretty-print-enabled console
such as Pry; otherwise, you'll see the output given by +inspect+.
If you want to learn more about how to create a matrix, {read the guide in our wiki}[https://github.com/SciRuby/nmatrix/wiki/How-to-create-an-NMatrix].
Again, you can find the complete API documentation {on our website}[http://sciruby.com/nmatrix/docs/].
=== Using advanced features provided by plugins
Certain features (see the documentation) require either the
nmatrix-atlas or the nmatrix-lapacke gem to be installed. These can be
accessed by using <tt>require 'nmatrix/atlas'</tt> or <tt>require
'nmatrix/lapacke'</tt>. If you don't care which of the two gems is
installed, use <tt>require 'nmatrix/lapack_plugin'</tt>, which will
require whichever one of the two is available.
Fast fourier transforms can be conducted with the nmatrix-fftw
extension, which is an interface to the FFTW C library. Use
<tt>require 'nmatrix/fftw'</tt> for using this plugin.
== Plugin details
=== ATLAS and LAPACKE
The +nmatrix-atlas+ and +nmatrix-lapacke+ gems are optional extensions
of the main +nmatrix+ gem that rely on external linear algebra libraries
to provide advanced features for dense matrices (singular value
decomposition, eigenvalue/eigenvector finding, Cholesky factorization),
as well as providing faster implementations of common operations like
multiplication, inverses, and determinants. +nmatrix-atlas+ requires the
{ATLAS library}[http://math-atlas.sourceforge.net/], while +nmatrix-lapacke+
is designed to work with various LAPACK implementations (including ATLAS).
The +nmatrix-atlas+ and +nmatrix-lapacke+ gems both provide similar
interfaces for using these advanced features.
=== *FFTW*
This is plugin for interfacing with the {FFTW library}[http://www.fftw.org].
It has been tested with FFTW 3.3.4.
It works reliably only with 64 bit numbers (or the NMatrix `:float64`
or `:complex128` data type). See the docs for more details.
== NArray compatibility
When NArray[http://masa16.github.io/narray/] is installed alongside
NMatrix, <tt>require 'nmatrix'</tt> will inadvertently load NArray's
+lib/nmatrix.rb+ file, usually accompanied by the following error:
uninitialized constant NArray (NameError)
To make sure NMatrix is loaded properly in the presence of NArray, use
<tt>require 'nmatrix/nmatrix'</tt> instead of <tt>require
'nmatrix'</tt> in your code.
== Developers
Read the instructions in +CONTRIBUTING.md+ if you want to help
NMatrix.
== Features
The following features exist in the current version of NMatrix (0.1.0.rc1):
* Matrix and vector storage containers: dense, yale, list (more to come)
* Data types: byte (uint8), int8, int16, int32, int64, float32, float64, complex64, complex128,
Ruby object
* Interconversion between storage and data types
* Element-wise and right-hand-scalar operations and comparisons for all matrix types
* Matrix-matrix multiplication for dense (with and without ATLAS) and yale
* Matrix-vector multiplication for dense (with and without ATLAS)
* Lots of enumerators (each, each_with_indices, each_row, each_column, each_rank, map, etc.)
* Matrix slicing by copy and reference (for dense, yale, and list)
* Native reading and writing of dense and yale matrices
* Optional compression for dense matrices with symmetry or triangularity: symmetric, skew, hermitian, upper, lower
* Input/output:
* Matlab .MAT v5 file input
* MatrixMarket file input/output
* Harwell-Boeing and Fortran file input
* Point Cloud Library PCD file input
* C and C++ API
* BLAS internal implementations (no library) and external (with nmatrix-lapack or nmatrix-atlas) access:
* Level 1: xROT, xROTG (BLAS dtypes only), xASUM, xNRM2, IxAMAX, xSCAL
* Level 2: xGEMV
* Level 3: xGEMM, xTRSM
* LAPACK access (with nmatrix-lapack or nmatrix-atlas plugin):
* xGETRF, xGETRI, xGETRS, xGESV (Gaussian elimination)
* xPOTRF, xPOTRI, xPOTRS, xPOSV (Cholesky factorization)
* xGESVD, xGESDD (singular value decomposition)
* xGEEV (eigenvalue decomposition of asymmetric square matrices)
* LAPACK-less internal implementations (no plugin or LAPACK needed and working on non-BLAS dtypes):
* xGETRF, xGETRS
* LU decomposition
* Matrix inversions
* Determinant calculation for BLAS dtypes
* Traces
* Ruby/GSL interoperability (requires {SciRuby's fork of rb-gsl}[http://github.com/SciRuby/rb-gsl])
* slice assignments, e.g.,
x[1..3,0..4] = some_other_matrix
=== Planned features (Short-to-Medium Term)
See the issues tracker for a list of planned features or to request
new ones.
== License
Copyright (c) 2012--17, John Woods and the Ruby Science Foundation.
All rights reserved.
NMatrix, along with SciRuby, is licensed under the BSD 2-clause
license. See {LICENSE.txt}[https://github.com/SciRuby/sciruby/wiki/License]
for details.
== Donations
Support a SciRuby Fellow:
{<img src=http://pledgie.com/campaigns/15783.png?skin_name=chrome>}[http://www.pledgie.com/campaigns/15783]
================================================
FILE: Rakefile
================================================
# -*- ruby -*-
require 'rubygems'
require 'rubygems/package_task'
require 'bundler'
#Specify plugins to build on the command line like:
#rake whatever nmatrix_plugins=atlas,lapacke
#or
#rake whatever nmatrix_plugins=all
#If you want to build *only* plugins and not the core nmatrix gem:
#rake whatever nmatrix_plugins=all nmatrix_core=false
if ENV["nmatrix_plugins"] == "all"
gemspecs = Dir["*.gemspec"]
else
plugins = []
plugins = ENV["nmatrix_plugins"].split(",") if ENV["nmatrix_plugins"]
gemspecs = ["nmatrix.gemspec"] #always include the main nmatrix gem
plugins.each do |plugin|
gemspecs << "nmatrix-#{plugin}.gemspec"
end
end
if ENV["nmatrix_core"] == "false"
gemspecs -= ["nmatrix.gemspec"]
end
gemspecs.map! { |gemspec| eval(IO.read(gemspec)) }
begin
Bundler.setup(:default, :development)
rescue Bundler::BundlerError => e
$stderr.puts e.message
$stderr.puts "Run `bundle install` to install missing gems"
exit e.status_code
end
desc "Build and install into system gems."
task :install => :repackage do
gemspecs.each do |gemspec|
gem_file = "pkg/#{gemspec.name}-#{gemspec.version}.gem"
system "gem install '#{gem_file}'"
end
end
require 'rake'
require "rake/extensiontask"
gemspecs.each do |gemspec|
next unless gemspec.extensions
gemspec.extensions.each do |extconf|
ext_name = extconf.match(/ext\/(.*)\/extconf\.rb/)[1]
Rake::ExtensionTask.new do |ext|
ext.name = ext_name
ext.ext_dir = "ext/#{ext_name}"
ext.lib_dir = 'lib/'
ext.source_pattern = "**/*.{c,cpp,h}"
end
end
end
gemspecs.each do |gemspec|
Gem::PackageTask.new(gemspec).define
end
require 'rspec/core/rake_task'
require 'rspec/core'
namespace :spec do
#We need a separate rake task for each plugin, rather than one big task that
#runs all of the specs. This is because there's no way to tell rspec
#to run the specs in a certain order with (say) "nmatrix/atlas" require'd
#for some of the specs, but not for others, without splitting them up like
#this.
spec_tasks = []
gemspecs.each do |gemspec|
test_files = gemspec.test_files
test_files.keep_if { |file| file =~ /_spec\.rb$/ }
test_files -= ['spec/nmatrix_yale_spec.rb', 'spec/blas_spec.rb', 'spec/lapack_core_spec.rb'] if /java/ === RUBY_PLATFORM
next if test_files.empty?
spec_tasks << gemspec.name
RSpec::Core::RakeTask.new(gemspec.name) do |spec|
spec.pattern = FileList.new(test_files)
end
end
task :all => spec_tasks
end
task :spec => "spec:all"
BASEDIR = Pathname( __FILE__ ).dirname.relative_path_from( Pathname.pwd )
SPECDIR = BASEDIR + 'spec'
VALGRIND_OPTIONS = [
"--tool=memcheck",
#"--leak-check=yes",
"--num-callers=15",
#"--error-limit=no",
"--partial-loads-ok=yes",
"--undef-value-errors=no" #,
#"--dsymutil=yes"
]
CALLGRIND_OPTIONS = [
"--tool=callgrind",
"--dump-instr=yes",
"--simulate-cache=yes",
"--collect-jumps=yes"
]
VALGRIND_MEMORYFILL_OPTIONS = [
"--freelist-vol=100000000",
"--malloc-fill=6D",
"--free-fill=66 ",
]
GDB_OPTIONS = []
task :console do |task|
cmd = [ 'irb', "-r './lib/nmatrix.rb'" ]
run *cmd
end
task :pry do |task|
cmd = [ 'pry', "-r './lib/nmatrix.rb'" ]
run *cmd
end
namespace :pry do
task :valgrind => [ :compile ] do |task|
cmd = [ 'valgrind' ] + VALGRIND_OPTIONS
cmd += ['ruby', '-Ilib:ext', "-r './lib/nmatrix.rb'", "-r 'pry'", "-e 'binding.pry'"]
run *cmd
end
end
namespace :console do
CONSOLE_CMD = ['irb', "-r './lib/nmatrix.rb'"]
desc "Run console under GDB."
task :gdb => [ :compile ] do |task|
cmd = [ 'gdb' ] + GDB_OPTIONS
cmd += [ '--args' ]
cmd += CONSOLE_CMD
run( *cmd )
end
desc "Run console under Valgrind."
task :valgrind => [ :compile ] do |task|
cmd = [ 'valgrind' ] + VALGRIND_OPTIONS
cmd += CONSOLE_CMD
run( *cmd )
end
end
task :default => :spec
def run *cmd
sh(cmd.join(" "))
end
namespace :spec do
# partial-loads-ok and undef-value-errors necessary to ignore
# spurious (and eminently ignorable) warnings from the ruby
# interpreter
RSPEC_CMD = [ 'ruby', '-S', 'rspec', '-Ilib:ext', SPECDIR.to_s ]
#desc "Run the spec for generator.rb"
#task :generator do |task|
# run 'rspec spec/generator_spec.rb'
#end
desc "Run specs under GDB."
task :gdb => [ :compile ] do |task|
cmd = [ 'gdb' ] + GDB_OPTIONS
cmd += [ '--args' ]
cmd += RSPEC_CMD
run( *cmd )
end
desc "Run specs under cgdb."
task :cgdb => [ :compile ] do |task|
cmd = [ 'cgdb' ] + GDB_OPTIONS
cmd += [ '--args' ]
cmd += RSPEC_CMD
run( *cmd )
end
desc "Run specs under Valgrind."
task :valgrind => [ :compile ] do |task|
cmd = [ 'valgrind' ] + VALGRIND_OPTIONS
cmd += RSPEC_CMD
run( *cmd )
end
desc "Run specs under Callgrind."
task :callgrind => [ :compile ] do |task|
cmd = [ 'valgrind' ] + CALLGRIND_OPTIONS
cmd += RSPEC_CMD
run( *cmd )
end
end
LEAKCHECK_CMD = [ 'ruby', '-Ilib:ext', "#{SPECDIR}/leakcheck.rb" ]
desc "Run leakcheck script."
task :leakcheck => [ :compile ] do |task|
cmd = [ 'valgrind' ] + VALGRIND_OPTIONS
cmd += LEAKCHECK_CMD
run( *cmd )
end
namespace :clean do
#the generated Makefile doesn't have a soclean target, should this be removed?
task :so do |task|
gemspecs.each do |gemspec|
next unless gemspec.extensions
gemspec.extensions.each do |extconf|
ext_name = extconf.match(/ext\/(.*)\/extconf\.rb/)[1]
tmp_path = "tmp/#{RUBY_PLATFORM}/#{ext_name}/#{RUBY_VERSION}"
chdir tmp_path do
if RUBY_PLATFORM =~ /mswin/
`nmake soclean`
else
mkcmd = ENV['MAKE'] || %w[gmake make].find { |c| system("#{c} -v >> /dev/null 2>&1") }
`#{mkcmd} soclean`
end
end
end
end
end
end
desc "Check the manifest for correctness"
task :check_manifest do |task|
manifest_files = File.read("Manifest.txt").split
git_files = `git ls-files |grep -v 'spec/'`.split
ignore_files = %w{.gitignore .rspec ext/nmatrix/binary_format.txt scripts/ttable_helper.rb}
possible_files = git_files - ignore_files
missing_files = possible_files - manifest_files
extra_files = manifest_files - possible_files
unless missing_files.empty?
STDERR.puts "The following files are in the git repo but not the Manifest:"
missing_files.each { |f| STDERR.puts " -- #{f}"}
end
unless extra_files.empty?
STDERR.puts "The following files are in the Manifest but may not be necessary:"
extra_files.each { |f| STDERR.puts " -- #{f}"}
end
if extra_files.empty? && missing_files.empty?
STDERR.puts "Manifest looks good!"
end
end
require "rdoc/task"
#separate out docs for plugins?
RDoc::Task.new do |rdoc|
rdoc.main = "README.rdoc"
rdoc.rdoc_files.include(%w{README.rdoc History.txt LICENSE.txt CONTRIBUTING.md lib ext})
rdoc.options << "--exclude=ext/nmatrix/extconf.rb"
rdoc.options << "--exclude=ext/nmatrix_atlas/extconf.rb"
rdoc.options << "--exclude=ext/nmatrix/ttable_helper.rb"
rdoc.options << "--exclude=lib/nmatrix/rspec.rb"
end
# jruby tasks
namespace :jruby do
PROJECT_DIR = File.expand_path(".",Dir.pwd)
BUILD_DIR = "build"
CLASSES_DIR = "../build/classes"
TEST_CLASSES_DIR = "build/testClasses"
JRUBY_DIR = "#{PROJECT_DIR}/ext/nmatrix_java"
VENDOR_DIR = "#{JRUBY_DIR}/vendor"
TARGET_DIR = "#{JRUBY_DIR}/target"
jars = Dir["#{VENDOR_DIR}/*.jar"]
desc 'Compile java classes'
task :javac do
unless RUBY_PLATFORM == 'java'
abort 'Please run with JRuby'
end
sh "mkdir -p #{JRUBY_DIR}/build/classes"
Dir.chdir("#{JRUBY_DIR}/nmatrix")
classes = Dir['**/*.java']
sh "javac -classpath #{jars.join(':')} -d #{CLASSES_DIR} #{classes.join(' ')}"
end
desc 'Package java classes in a jar file'
task :jar do
unless RUBY_PLATFORM == 'java'
abort 'Please run with JRuby'
end
sh "mkdir -p #{TARGET_DIR}"
Dir.chdir("#{JRUBY_DIR}/build/classes")
classes = Dir['**/*.class']
sh "jar -cf #{TARGET_DIR}/nmatrix.jar #{classes.join(' ')}"
end
task :all => [:javac, :jar]
end
desc "Compile java classes and Package them in a jar file"
task :jruby => 'jruby:all'
namespace :travis do
task :env do
if /java/ === RUBY_PLATFORM
puts "Building for jruby"
sh "mkdir ext/nmatrix_java/vendor"
puts "Downloading tar file."
sh "wget http://www-eu.apache.org/dist//commons/math/binaries/commons-math3-3.6.1-bin.tar.gz"
puts "Unzipping tar file."
sh "tar -zxf commons-math3-3.6.1-bin.tar.gz"
puts "Deleting tar file."
sh "rm commons-math3-3.6.1-bin.tar.gz"
sh "cp -r commons-math3-3.6.1/commons-math3-3.6.1.jar ext/nmatrix_java/vendor"
else
puts "\n# Build environment:"
%w[
CC CXX
USE_ATLAS USE_OPENBLAS USE_REF NO_EXTERNAL_LIB
TRAVIS_OS_NAME TRAVIS_BRANCH TRAVIS_COMMIT TRAVIS_PULL_REQUEST
].each do |name|
puts "- #{name}: #{ENV[name]}"
end
require 'rbconfig'
puts "\n# RbConfig::MAKEFILE_CONFIG values:"
%w[
CC CXX CPPFLAGS CFLAGS CXXFLAGS
].each do |name|
puts "- #{name}: #{RbConfig::MAKEFILE_CONFIG[name]}"
end
cc = RbConfig::MAKEFILE_CONFIG['CC']
puts "\n$ #{cc} -v\n#{`#{cc} -v 2>&1`}"
end
end
end
# vim: syntax=ruby
================================================
FILE: ext/nmatrix/binary_format.txt
================================================
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.
================================================
FILE: ext/nmatrix/data/complex.h
================================================
/////////////////////////////////////////////////////////////////////
// = NMatrix
//
// A linear algebra library for scientific computation in Ruby.
// NMatrix is part of SciRuby.
//
// NMatrix was originally inspired by and derived from NArray, by
// Masahiro Tanaka: http://narray.rubyforge.org
//
// == Copyright Information
//
// SciRuby is Copyright (c) 2010 - 2014, Ruby Science Foundation
// NMatrix is Copyright (c) 2012 - 2014, John Woods and the Ruby Science Foundation
//
// Please see LICENSE.txt for additional copyright notices.
//
// == Contributing
//
// By contributing source code to SciRuby, you agree to be bound by
// our Contributor Agreement:
//
// * https://github.com/SciRuby/sciruby/wiki/Contributor-Agreement
//
// == complex.h
//
// Functions and classes for dealing with complex numbers.
#ifndef COMPLEX_H
#define COMPLEX_H
/*
* Standard Includes
*/
#include <ruby.h>
#include <type_traits>
#include <iostream>
#include <cmath>
/*
* Project Includes
*/
#include "types.h"
/*
* Macros
*/
/*
* Types
*/
namespace nm {
class RubyObject;
template <typename Type> class Complex;
typedef Complex<float32_t> Complex64;
typedef Complex<float64_t> Complex128;
/*
* Data
*/
/*
* Classes and Functions
*/
template <typename Type>
class Complex {
public:
// The real and immaginary parts of the complex number.
Type r;
Type i;
/*
* Default constructor.
*/
inline Complex(Type real = 0, Type imaginary = 0) : r(real), i(imaginary) {}
/*
* Copy constructors.
*/
template <typename ComplexType>
explicit inline Complex(const Complex<ComplexType>& other) : r(other.r), i(other.i) {}
template <typename ComplexType>
inline Complex<Type>& operator=(const Complex<ComplexType>& other) {
this->r = static_cast<Type>(other.r);
this->i = static_cast<Type>(other.i);
return *this;
}
explicit Complex(const RubyObject& other);
Complex<Type>& operator=(const RubyObject& other);
template<typename OtherType>
inline Complex<Type>& operator=(const OtherType& real) {
this->r = Type(real);
this->i = Type(0);
return *this;
}
/*
* Complex conjugate function -- creates a copy, but inverted.
*/
inline Complex<Type> conjugate() const {
return Complex<Type>(this->r, -(this->i));
}
/*
* Complex inverse function -- creates a copy, but inverted.
*
* FIXME: Check that this doesn't duplicate functionality of NativeType / Complex<Type>
*/
inline Complex<Type> inverse() const {
Complex<Type> conj = conjugate();
Type denom = this->r * this->r + this->i * this->i;
return Complex<Type>(conj.r / denom, conj.i / denom);
}
// Negative operator
inline Complex<Type> operator-() const {
return Complex<Type>(-this->r, -this->i);
}
/*
* Binary operator definitions for various types.
*/
////////////////////////////////
// Complex-Complex Operations //
////////////////////////////////
template <typename OtherType>
inline Complex<Type> operator+(const Complex<OtherType>& other) const {
return Complex<Type>(this->r + other.r, this->i + other.i);
}
template <typename OtherType>
inline Complex<Type>& operator+=(const Complex<OtherType>& other) {
this->r += other.r;
this->i += other.i;
return *this;
}
template <typename OtherType>
inline Complex<Type>& operator-=(const Complex<OtherType>& other) {
this->r -= other.r;
this->i -= other.i;
return *this;
}
template <typename OtherType>
inline Complex<Type> operator-(const Complex<OtherType>& other) const {
return Complex<Type>(this->r - other.r, this->i - other.i);
}
template <typename OtherType>
inline Complex<Type> operator*(const Complex<OtherType>& other) const {
return Complex<Type>(this->r * other.r - this->i * other.i, this->r * other.i + this->i * other.r);
}
template <typename OtherType>
inline Complex<Type>& operator*=(const Complex<OtherType>& other) {
this->r = this->r * other.r - this->i * other.i;
this->i = this->r * other.i + this->i * other.r;
return *this;
}
template <typename OtherType>
inline Complex<Type> operator/(const Complex<OtherType>& other) const {
Type new_r, new_i;
Type denom = other.i * other.i + other.r * other.r;
new_r = (this->r * other.r + this->i * other.i) / denom;
new_i = (this->i * other.r - this->r * other.i) / denom;
return Complex<Type>(new_r, new_i);
}
template <typename OtherType>
inline Complex<Type> operator/=(const Complex<OtherType>& other) {
Type new_r, new_i;
Type denom = other.i * other.i + other.r * other.r;
new_r = (this->r * other.r + this->i * other.i) / denom;
new_i = (this->i * other.r - this->r * other.i) / denom;
this->r = new_r;
this->i = new_i;
return *this;
}
template <typename OtherType>
inline bool operator<(const Complex<OtherType>& other) const {
return (this->r < other.r) || ((this->r <= other.r) && (this->i < other.i));
}
template <typename OtherType>
inline bool operator>(const Complex<OtherType>& other) const {
return (this->r > other.r) || ((this->r >= other.r) && (this->i > other.i));
}
template <typename OtherType>
inline bool operator==(const Complex<OtherType>& other) const {
return FP_EQUAL(this->r, other.r) && FP_EQUAL(this->i, other.i);
}
template <typename OtherType>
inline bool operator!=(const Complex<OtherType>& other) const {
return !(*this == other);
}
template <typename OtherType>
inline bool operator<=(const Complex<OtherType>& other) const {
return (*this < other) || (*this == other);
}
template <typename OtherType>
inline bool operator>=(const Complex<OtherType>& other) const {
return (*this > other) || (*this == other);
}
template <typename OtherType>
inline operator Complex<OtherType> () const {
return Complex<OtherType>((OtherType)this->r, (OtherType)this->i);
}
///////////////////////////////
// Complex-Native Operations //
///////////////////////////////
template <typename NativeType, typename = typename std::enable_if<std::is_arithmetic<NativeType>::value>::type>
inline Complex<Type> operator+(const NativeType& other) const {
return *this + Complex<Type>(other);
}
template <typename NativeType, typename = typename std::enable_if<std::is_arithmetic<NativeType>::value>::type>
inline Complex<Type> operator-(const NativeType& other) const {
return *this - Complex<Type>(other);
}
template <typename NativeType, typename = typename std::enable_if<std::is_arithmetic<NativeType>::value>::type>
inline Complex<Type> operator*(const NativeType& other) const {
return *this * Complex<Type>(other);
}
template <typename NativeType, typename = typename std::enable_if<std::is_arithmetic<NativeType>::value>::type>
inline Complex<Type> operator/(const NativeType& other) const {
return *this / Complex<Type>(other);
}
template <typename NativeType, typename = typename std::enable_if<std::is_arithmetic<NativeType>::value>::type>
inline bool operator<(const NativeType& other) const {
return *this < Complex<Type>(other);
}
template <typename NativeType, typename = typename std::enable_if<std::is_arithmetic<NativeType>::value>::type>
inline bool operator>(const NativeType& other) const {
return *this > Complex<Type>(other);
}
template <typename NativeType, typename = typename std::enable_if<std::is_arithmetic<NativeType>::value>::type>
inline bool operator==(const NativeType& other) const {
return *this == Complex<Type>(other);
}
template <typename NativeType, typename = typename std::enable_if<std::is_arithmetic<NativeType>::value>::type>
inline bool operator!=(const NativeType& other) const {
return *this != Complex<Type>(other);
}
template <typename NativeType, typename = typename std::enable_if<std::is_arithmetic<NativeType>::value>::type>
inline bool operator<=(const NativeType& other) const {
return *this <= Complex<Type>(other);
}
template <typename NativeType, typename = typename std::enable_if<std::is_arithmetic<NativeType>::value>::type>
inline bool operator>=(const NativeType& other) const {
return *this >= Complex<Type>(other);
}
template <typename NativeType, typename = typename std::enable_if<std::is_arithmetic<NativeType>::value>::type>
inline operator NativeType () const {
return (NativeType)this->r;
}
operator RubyObject () const;
};
///////////////////////////////
// Native-Complex Operations //
///////////////////////////////
template <typename NativeType, typename ComplexType, typename = typename std::enable_if<std::is_arithmetic<NativeType>::value>::type>
inline Complex<ComplexType> operator+(const NativeType& left, const Complex<ComplexType>& right) {
return Complex<ComplexType>(left) + right;
}
template <typename NativeType, typename ComplexType, typename = typename std::enable_if<std::is_arithmetic<NativeType>::value>::type>
inline Complex<ComplexType> operator-(const NativeType& left, const Complex<ComplexType>& right) {
return Complex<ComplexType>(left) - right;
}
template <typename NativeType, typename ComplexType, typename = typename std::enable_if<std::is_arithmetic<NativeType>::value>::type>
inline Complex<ComplexType> operator*(const NativeType& left, const Complex<ComplexType>& right) {
return Complex<ComplexType>(left) * right;
}
template <typename NativeType, typename ComplexType, typename = typename std::enable_if<std::is_arithmetic<NativeType>::value>::type>
inline Complex<ComplexType> operator/(const NativeType& left, const Complex<ComplexType>& right) {
return Complex<ComplexType>(left) / right;
}
template <typename NativeType, typename ComplexType, typename = typename std::enable_if<std::is_arithmetic<NativeType>::value>::type>
inline bool operator<(const NativeType left, const Complex<ComplexType>& right) {
return Complex<ComplexType>(left) < right;
}
template <typename NativeType, typename ComplexType, typename = typename std::enable_if<std::is_arithmetic<NativeType>::value>::type>
inline bool operator>(const NativeType left, const Complex<ComplexType>& right) {
return Complex<ComplexType>(left) > right;
}
template <typename NativeType, typename ComplexType, typename = typename std::enable_if<std::is_arithmetic<NativeType>::value>::type>
inline bool operator==(const NativeType left, const Complex<ComplexType>& right) {
return Complex<ComplexType>(left) == right;
}
template <typename NativeType, typename ComplexType, typename = typename std::enable_if<std::is_arithmetic<NativeType>::value>::type>
inline bool operator!=(const NativeType left, const Complex<ComplexType>& right) {
return Complex<ComplexType>(left) != right;
}
template <typename NativeType, typename ComplexType, typename = typename std::enable_if<std::is_arithmetic<NativeType>::value>::type>
inline bool operator<=(const NativeType left, const Complex<ComplexType>& right) {
return Complex<ComplexType>(left) <= right;
}
template <typename NativeType, typename ComplexType, typename = typename std::enable_if<std::is_arithmetic<NativeType>::value>::type>
inline bool operator>=(const NativeType left, const Complex<ComplexType>& right) {
return Complex<ComplexType>(left) >= right;
}
template <typename Type>
inline std::ostream& operator<<(std::ostream& out, const Complex<Type>& rhs) {
out << "(" << rhs.r << "," << rhs.i << "i)" << std::flush;
return out;
}
// Negative operator
template <typename IntType, typename = typename std::enable_if<std::is_integral<IntType>::value>::type>
inline Complex<IntType> operator-(const Complex<IntType>& rhs) {
return Complex<IntType>(-rhs.r, -rhs.i);
}
} // end of namespace nm
namespace std {
template <typename FloatType, typename = typename std::enable_if<std::is_floating_point<FloatType>::value>::type>
nm::Complex<FloatType> piecewise_abs(const nm::Complex<FloatType>& value) {
return nm::Complex<FloatType>(value.r < 0 ? -value.r : value.r,
value.i < 0 ? -value.i : value.i);
}
template <typename FloatType, typename = typename std::enable_if<std::is_floating_point<FloatType>::value>::type>
nm::Complex<FloatType> real_abs(const nm::Complex<FloatType>& value) {
return nm::Complex<FloatType>(value.r < 0 ? -value.r : value.r,
value.i);
}
template <typename FloatType, typename = typename std::enable_if<std::is_floating_point<FloatType>::value>::type>
nm::Complex<FloatType> imag_abs(const nm::Complex<FloatType>& value) {
return nm::Complex<FloatType>(value.r,
value.i < 0 ? -value.i : value.i);
}
template <typename FloatType, typename = typename std::enable_if<std::is_floating_point<FloatType>::value>::type>
double abs(const nm::Complex<FloatType>& value) {
return std::sqrt(double(value.r)*double(value.r) + double(value.i)*double(value.i));
}
}
#endif // COMPLEX_H
================================================
FILE: ext/nmatrix/data/data.cpp
================================================
/////////////////////////////////////////////////////////////////////
// = NMatrix
//
// A linear algebra library for scientific computation in Ruby.
// NMatrix is part of SciRuby.
//
// NMatrix was originally inspired by and derived from NArray, by
// Masahiro Tanaka: http://narray.rubyforge.org
//
// == Copyright Information
//
// SciRuby is Copyright (c) 2010 - 2014, Ruby Science Foundation
// NMatrix is Copyright (c) 2012 - 2014, John Woods and the Ruby Science Foundation
//
// Please see LICENSE.txt for additional copyright notices.
//
// == Contributing
//
// By contributing source code to SciRuby, you agree to be bound by
// our Contributor Agreement:
//
// * https://github.com/SciRuby/sciruby/wiki/Contributor-Agreement
//
// == data.cpp
//
// Functions and data for dealing the data types.
/*
* Standard Includes
*/
#include <ruby.h>
#include <stdexcept>
/*
* Project Includes
*/
#include "types.h"
#include "data.h"
/*
* Global Variables
*/
namespace nm {
const char* const EWOP_OPS[nm::NUM_EWOPS] = {
"+",
"-",
"*",
"/",
"**",
"%",
"==",
"!=",
"<",
">",
"<=",
">="
};
const std::string EWOP_NAMES[nm::NUM_EWOPS] = {
"add",
"sub",
"mul",
"div",
"pow",
"mod",
"eqeq",
"neq",
"lt",
"gt",
"leq",
"geq"
};
const std::string NONCOM_EWOP_NAMES[nm::NUM_NONCOM_EWOPS] = {
"atan2",
"ldexp",
"hypot"
};
const std::string UNARYOPS[nm::NUM_UNARYOPS] = {
"sin", "cos", "tan",
"asin", "acos", "atan",
"sinh", "cosh", "tanh",
"asinh", "acosh", "atanh",
"exp", "log2",
"log10", "sqrt", "erf",
"erfc", "cbrt", "gamma",
"negate", "floor", "ceil", "round"
};
/*
* 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, nm::dtype_t dtype) {
using namespace nm;
switch (dtype) {
case BYTE:
return RubyObject(*reinterpret_cast<uint8_t*>(val));
case INT8:
return RubyObject(*reinterpret_cast<int8_t*>(val));
case INT16:
return RubyObject(*reinterpret_cast<int16_t*>(val));
case INT32:
return RubyObject(*reinterpret_cast<int32_t*>(val));
case INT64:
return RubyObject(*reinterpret_cast<int64_t*>(val));
case FLOAT32:
return RubyObject(*reinterpret_cast<float32_t*>(val));
case FLOAT64:
return RubyObject(*reinterpret_cast<float64_t*>(val));
case COMPLEX64:
return RubyObject(*reinterpret_cast<Complex64*>(val));
case COMPLEX128:
return RubyObject(*reinterpret_cast<Complex128*>(val));
default:
try {
throw std::logic_error("Cannot create ruby object");
}
catch (std::logic_error err) {
printf("%s\n", err.what());
}
rb_raise(nm_eDataTypeError, "Conversion to RubyObject requested from unknown/invalid data type (did you try to convert from a VALUE?)");
}
return Qnil;
}
} // end of namespace nm
extern "C" {
const char* const DTYPE_NAMES[nm::NUM_DTYPES] = {
"byte",
"int8",
"int16",
"int32",
"int64",
"float32",
"float64",
"complex64",
"complex128",
"object"
};
const size_t DTYPE_SIZES[nm::NUM_DTYPES] = {
sizeof(uint8_t),
sizeof(int8_t),
sizeof(int16_t),
sizeof(int32_t),
sizeof(int64_t),
sizeof(float32_t),
sizeof(float64_t),
sizeof(nm::Complex64),
sizeof(nm::Complex128),
sizeof(nm::RubyObject)
};
const nm::dtype_t Upcast[nm::NUM_DTYPES][nm::NUM_DTYPES] = {
{ nm::BYTE, nm::INT16, nm::INT16, nm::INT32, nm::INT64, nm::FLOAT32, nm::FLOAT64, nm::COMPLEX64, nm::COMPLEX128, nm::RUBYOBJ},
{ nm::INT16, nm::INT8, nm::INT16, nm::INT32, nm::INT64, nm::FLOAT32, nm::FLOAT64, nm::COMPLEX64, nm::COMPLEX128, nm::RUBYOBJ},
{ nm::INT16, nm::INT16, nm::INT16, nm::INT32, nm::INT64, nm::FLOAT32, nm::FLOAT64, nm::COMPLEX64, nm::COMPLEX128, nm::RUBYOBJ},
{ nm::INT32, nm::INT32, nm::INT32, nm::INT32, nm::INT64, nm::FLOAT32, nm::FLOAT64, nm::COMPLEX64, nm::COMPLEX128, nm::RUBYOBJ},
{ nm::INT64, nm::INT64, nm::INT64, nm::INT64, nm::INT64, nm::FLOAT32, nm::FLOAT64, nm::COMPLEX64, nm::COMPLEX128, nm::RUBYOBJ},
{ nm::FLOAT32, nm::FLOAT32, nm::FLOAT32, nm::FLOAT32, nm::FLOAT32, nm::FLOAT32, nm::FLOAT64, nm::COMPLEX64, nm::COMPLEX128, nm::RUBYOBJ},
{ nm::FLOAT64, nm::FLOAT64, nm::FLOAT64, nm::FLOAT64, nm::FLOAT64, nm::FLOAT64, nm::FLOAT64, nm::COMPLEX128, nm::COMPLEX128, nm::RUBYOBJ},
{ nm::COMPLEX64, nm::COMPLEX64, nm::COMPLEX64, nm::COMPLEX64, nm::COMPLEX64, nm::COMPLEX64, nm::COMPLEX128, nm::COMPLEX64, nm::COMPLEX128, nm::RUBYOBJ},
{ nm::COMPLEX128, nm::COMPLEX128, nm::COMPLEX128, nm::COMPLEX128, nm::COMPLEX128, nm::COMPLEX128, nm::COMPLEX128, nm::COMPLEX128, nm::COMPLEX128, nm::RUBYOBJ},
{ nm::RUBYOBJ, nm::RUBYOBJ, nm::RUBYOBJ, nm::RUBYOBJ, nm::RUBYOBJ, nm::RUBYOBJ, nm::RUBYOBJ, nm::RUBYOBJ, nm::RUBYOBJ, nm::RUBYOBJ}
};
/*
* Forward Declarations
*/
/*
* Functions
*/
/*
* Converts a RubyObject
*/
void rubyval_to_cval(VALUE val, nm::dtype_t dtype, void* loc) {
using namespace nm;
switch (dtype) {
case nm::BYTE:
*reinterpret_cast<uint8_t*>(loc) = static_cast<uint8_t>(RubyObject(val));
break;
case nm::INT8:
*reinterpret_cast<int8_t*>(loc) = static_cast<int8_t>(RubyObject(val));
break;
case nm::INT16:
*reinterpret_cast<int16_t*>(loc) = static_cast<int16_t>(RubyObject(val));
break;
case nm::INT32:
*reinterpret_cast<int32_t*>(loc) = static_cast<int32_t>(RubyObject(val));
break;
case nm::INT64:
*reinterpret_cast<int64_t*>(loc) = static_cast<int64_t>(RubyObject(val));
break;
case nm::FLOAT32:
*reinterpret_cast<float32_t*>(loc) = static_cast<float32_t>(RubyObject(val));
break;
case nm::FLOAT64:
*reinterpret_cast<float64_t*>(loc) = static_cast<float64_t>(RubyObject(val));
break;
case nm::COMPLEX64:
*reinterpret_cast<Complex64*>(loc) = RubyObject(val).to<Complex64>();
break;
case nm::COMPLEX128:
*reinterpret_cast<Complex128*>(loc) = RubyObject(val).to<Complex128>();
break;
case RUBYOBJ:
*reinterpret_cast<VALUE*>(loc) = val;
//rb_raise(rb_eTypeError, "Attempting a bad conversion from a Ruby value.");
break;
default:
rb_raise(rb_eTypeError, "Attempting a bad conversion.");
break;
}
}
/*
* Allocate and return a piece of data of the correct dtype, converted from a
* given RubyObject.
*/
void* rubyobj_to_cval(VALUE val, nm::dtype_t dtype) {
size_t size = DTYPE_SIZES[dtype];
NM_CONSERVATIVE(nm_register_value(&val));
void* ret_val = NM_ALLOC_N(char, size);
rubyval_to_cval(val, dtype, ret_val);
NM_CONSERVATIVE(nm_unregister_value(&val));
return ret_val;
}
void nm_init_data() {
volatile VALUE t = INT2FIX(1);
volatile nm::RubyObject obj(t);
volatile nm::Complex64 a(const_cast<nm::RubyObject&>(obj));
volatile nm::Complex128 b(const_cast<nm::RubyObject&>(obj));
}
} // end of extern "C" block
================================================
FILE: ext/nmatrix/data/data.h
================================================
/////////////////////////////////////////////////////////////////////
// = NMatrix
//
// A linear algebra library for scientific computation in Ruby.
// NMatrix is part of SciRuby.
//
// NMatrix was originally inspired by and derived from NArray, by
// Masahiro Tanaka: http://narray.rubyforge.org
//
// == Copyright Information
//
// SciRuby is Copyright (c) 2010 - 2014, Ruby Science Foundation
// NMatrix is Copyright (c) 2012 - 2014, John Woods and the Ruby Science Foundation
//
// Please see LICENSE.txt for additional copyright notices.
//
// == Contributing
//
// By contributing source code to SciRuby, you agree to be bound by
// our Contributor Agreement:
//
// * https://github.com/SciRuby/sciruby/wiki/Contributor-Agreement
//
// == data.h
//
// Header file for dealing with data types.
#ifndef DATA_H
#define DATA_H
/*
* Standard Includes
*/
#include <ruby.h>
#include <string>
/*
* Project Includes
*/
#include "nmatrix.h"
#include "types.h"
#include "complex.h"
#include "ruby_object.h"
namespace nm {
/*
* Constants
*/
const int NUM_DTYPES = 10;
const int NUM_ITYPES = 4;
const int NUM_EWOPS = 12;
const int NUM_UNARYOPS = 24;
const int NUM_NONCOM_EWOPS = 3;
enum ewop_t {
EW_ADD,
EW_SUB,
EW_MUL,
EW_DIV,
EW_POW,
EW_MOD,
EW_EQEQ,
EW_NEQ,
EW_LT,
EW_GT,
EW_LEQ,
EW_GEQ,
};
enum noncom_ewop_t {
NONCOM_EW_ATAN2,
NONCOM_EW_LDEXP,
NONCOM_EW_HYPOT
};
enum unaryop_t {
UNARY_SIN,
UNARY_COS,
UNARY_TAN,
UNARY_ASIN,
UNARY_ACOS,
UNARY_ATAN,
UNARY_SINH,
UNARY_COSH,
UNARY_TANH,
UNARY_ASINH,
UNARY_ACOSH,
UNARY_ATANH,
UNARY_EXP,
UNARY_LOG2,
UNARY_LOG10,
UNARY_SQRT,
UNARY_ERF,
UNARY_ERFC,
UNARY_CBRT,
UNARY_GAMMA,
UNARY_NEGATE,
UNARY_FLOOR,
UNARY_CEIL,
UNARY_ROUND
};
// element-wise and scalar operators
extern const char* const EWOP_OPS[nm::NUM_EWOPS];
extern const std::string EWOP_NAMES[nm::NUM_EWOPS];
extern const std::string UNARYOPS[nm::NUM_UNARYOPS];
extern const std::string NONCOM_EWOP_NAMES[nm::NUM_NONCOM_EWOPS];
template <typename Type>
Complex<Type>::Complex(const RubyObject& other) {
*this = other;
}
template <typename Type>
Complex<Type>& Complex<Type>::operator=(const RubyObject& other) {
if (RB_TYPE_P(other.rval, T_COMPLEX)) {
this->r = NUM2DBL(rb_funcall(other.rval, rb_intern("real"), 0));
this->i = NUM2DBL(rb_funcall(other.rval, rb_intern("imag"), 0));
}
else if (RB_TYPE_P(other.rval, T_FLOAT) ||
RB_TYPE_P(other.rval, T_FIXNUM) ||
RB_TYPE_P(other.rval, T_BIGNUM)) {
this->r = NUM2DBL(other.rval);
this->i = 0.0;
}
else {
rb_raise(rb_eTypeError, "not sure how to convert this type of VALUE to a complex");
}
return *this;
}
template<typename Type>
Complex<Type>::operator RubyObject () const {
return RubyObject(*this);
}
nm::RubyObject rubyobj_from_cval(void* val, nm::dtype_t dtype);
} // end of namespace nm
/*
* Macros
*/
#define STYPE_MARK_TABLE(name) \
static void (*(name)[nm::NUM_STYPES])(STORAGE*) = { \
nm_dense_storage_mark, \
nm_list_storage_mark, \
nm_yale_storage_mark \
};
#define STYPE_REGISTER_TABLE(name) \
static void (*(name)[nm::NUM_STYPES])(const STORAGE*) = { \
nm_dense_storage_register, \
nm_list_storage_register, \
nm_yale_storage_register \
};
#define STYPE_UNREGISTER_TABLE(name) \
static void (*(name)[nm::NUM_STYPES])(const STORAGE*) = { \
nm_dense_storage_unregister, \
nm_list_storage_unregister, \
nm_yale_storage_unregister \
};
#define CAST_TABLE(name) \
static STORAGE* (*(name)[nm::NUM_STYPES][nm::NUM_STYPES])(const STORAGE*, nm::dtype_t, void*) = { \
{ 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 } \
};
/*
* Defines a static array that hold function pointers to dtype templated
* versions of the specified function.
*/
#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::RubyObject> \
};
#define DTYPE_OBJECT_STATIC_TABLE(obj, fun, ret, ...) \
static ret (*(ttable)[nm::NUM_DTYPES])(__VA_ARGS__) = { \
obj<uint8_t>::fun, \
obj<int8_t>::fun, \
obj<int16_t>::fun, \
obj<int32_t>::fun, \
obj<int64_t>::fun, \
obj<float32_t>::fun, \
obj<float64_t>::fun, \
obj<nm::Complex64>::fun, \
obj<nm::Complex128>::fun, \
obj<nm::RubyObject>::fun \
};
#define NAMED_DTYPE_TEMPLATE_TABLE_NO_ROBJ(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> \
};
/*
* Same as DTYPE_TEMPLATE_TABLE but for functions that have two template
* parameters.
*
* The left-hand DType is used as the first index, and the right-hand side is
* the second index. Not all left- and right-hand side combinations are valid,
* and an invalid combination will result in a NULL pointer.
*/
#define LR_DTYPE_TEMPLATE_TABLE(fun, ret, ...) NAMED_LR_DTYPE_TEMPLATE_TABLE(ttable, fun, ret, __VA_ARGS__)
#define NAMED_LR_DTYPE_TEMPLATE_TABLE(name, fun, ret, ...) \
static ret (*(name)[nm::NUM_DTYPES][nm::NUM_DTYPES])(__VA_ARGS__) = { \
{fun<uint8_t, uint8_t>, fun<uint8_t, int8_t>, fun<uint8_t, int16_t>, fun<uint8_t, int32_t>, fun<uint8_t, int64_t>, fun<uint8_t, float32_t>, fun<uint8_t, float64_t>, fun<uint8_t, nm::Complex64>, fun<uint8_t, nm::Complex128>, fun<uint8_t, nm::RubyObject>}, \
{fun<int8_t, uint8_t>, fun<int8_t, int8_t>, fun<int8_t, int16_t>, fun<int8_t, int32_t>, fun<int8_t, int64_t>, fun<int8_t, float32_t>, fun<int8_t, float64_t>, fun<int8_t, nm::Complex64>, fun<int8_t, nm::Complex128>, fun<int8_t, nm::RubyObject>}, \
{fun<int16_t, uint8_t>, fun<int16_t, int8_t>, fun<int16_t, int16_t>, fun<int16_t, int32_t>, fun<int16_t, int64_t>, fun<int16_t, float32_t>, fun<int16_t, float64_t>, fun<int16_t, nm::Complex64>, fun<int16_t, nm::Complex128>, fun<int16_t, nm::RubyObject>}, \
{fun<int32_t, uint8_t>, fun<int32_t, int8_t>, fun<int32_t, int16_t>, fun<int32_t, int32_t>, fun<int32_t, int64_t>, fun<int32_t, float32_t>, fun<int32_t, float64_t>, fun<int32_t, nm::Complex64>, fun<int32_t, nm::Complex128>, fun<int32_t, nm::RubyObject>}, \
{fun<int64_t, uint8_t>, fun<int64_t, int8_t>, fun<int64_t, int16_t>, fun<int64_t, int32_t>, fun<int64_t, int64_t>, fun<int64_t, float32_t>, fun<int64_t, float64_t>, fun<int64_t, nm::Complex64>, fun<int64_t, nm::Complex128>, fun<int64_t, nm::RubyObject>}, \
{fun<float32_t, uint8_t>, fun<float32_t, int8_t>, fun<float32_t, int16_t>, fun<float32_t, int32_t>, fun<float32_t, int64_t>, fun<float32_t, float32_t>, fun<float32_t, float64_t>, fun<float32_t, nm::Complex64>, fun<float32_t, nm::Complex128>, fun<float32_t, nm::RubyObject>}, \
{fun<float64_t, uint8_t>, fun<float64_t, int8_t>, fun<float64_t, int16_t>, fun<float64_t, int32_t>, fun<float64_t, int64_t>, fun<float64_t, float32_t>, fun<float64_t, float64_t>, fun<float64_t, nm::Complex64>, fun<float64_t, nm::Complex128>, fun<float64_t, nm::RubyObject>}, \
{fun<nm::Complex64, uint8_t>, fun<nm::Complex64, int8_t>, fun<nm::Complex64, int16_t>, fun<nm::Complex64, int32_t>, fun<nm::Complex64, int64_t>, fun<nm::Complex64, float32_t>, fun<nm::Complex64, float64_t>, fun<nm::Complex64, nm::Complex64>, fun<nm::Complex64, nm::Complex128>, fun<nm::Complex64, nm::RubyObject>}, \
{fun<nm::Complex128, uint8_t>, fun<nm::Complex128, int8_t>, fun<nm::Complex128, int16_t>, fun<nm::Complex128, int32_t>, fun<nm::Complex128, int64_t>, fun<nm::Complex128, float32_t>, fun<nm::Complex128, float64_t>, fun<nm::Complex128, nm::Complex64>, fun<nm::Complex128, nm::Complex128>, fun<nm::Complex128, nm::RubyObject>}, \
{fun<nm::RubyObject, uint8_t>, fun<nm::RubyObject, int8_t>, fun<nm::RubyObject, int16_t>, fun<nm::RubyObject, int32_t>, fun<nm::RubyObject, int64_t>, fun<nm::RubyObject, float32_t>, fun<nm::RubyObject, float64_t>, fun<nm::RubyObject, nm::Complex64>, fun<nm::RubyObject, nm::Complex128>, fun<nm::RubyObject, nm::RubyObject>} \
};
/*
* Defines a static array that holds function pointers to operation, and left-
* and right-side dtype templated version sof the specified function.
*/
#define OP_LR_DTYPE_TEMPLATE_TABLE(fun, ret, ...) NAMED_OP_LR_DTYPE_TEMPLATE_TABLE(ttable, fun, ret, __VA_ARGS__)
#define NAMED_OP_LR_DTYPE_TEMPLATE_TABLE(name, fun, ret, ...) \
static ret (*(name)[nm::NUM_EWOPS][nm::NUM_DTYPES][nm::NUM_DTYPES])(__VA_ARGS__) = { \
{ \
{fun<nm::EW_ADD, uint8_t, uint8_t>, fun<nm::EW_ADD, uint8_t, int8_t>, fun<nm::EW_ADD, uint8_t, int16_t>, fun<nm::EW_ADD, uint8_t, int32_t>, fun<nm::EW_ADD, uint8_t, int64_t>, \
fun<nm::EW_ADD, uint8_t, float32_t>, fun<nm::EW_ADD, uint8_t, float64_t>, fun<nm::EW_ADD, uint8_t, nm::Complex64>, fun<nm::EW_ADD, uint8_t, nm::Complex128>, \
fun<nm::EW_ADD, int8_t, float32_t>, fun<nm::EW_ADD, int8_t, float64_t>, fun<nm::EW_ADD, int8_t, nm::Complex64>, fun<nm::EW_ADD, int8_t, nm::Complex128>, \
NULL}, \
\
{fun<nm::EW_ADD, int16_t, uint8_t>, fun<nm::EW_ADD, int16_t, int8_t>, fun<nm::EW_ADD, int16_t, int16_t>, fun<nm::EW_ADD, int16_t, int32_t>, fun<nm::EW_ADD, int16_t, int64_t>, \
fun<nm::EW_ADD, int16_t, float32_t>, fun<nm::EW_ADD, int16_t, float64_t>, fun<nm::EW_ADD, int16_t, nm::Complex64>, fun<nm::EW_ADD, int16_t, nm::Complex128>, \
NULL}, \
\
{fun<nm::EW_ADD, int32_t, uint8_t>, fun<nm::EW_ADD, int32_t, int8_t>, fun<nm::EW_ADD, int32_t, int16_t>, fun<nm::EW_ADD, int32_t, int32_t>, fun<nm::EW_ADD, int32_t, int64_t>, \
fun<nm::EW_ADD, int32_t, float32_t>, fun<nm::EW_ADD, int32_t, float64_t>, fun<nm::EW_ADD, int32_t, nm::Complex64>, fun<nm::EW_ADD, int32_t, nm::Complex128>, \
NULL}, \
\
{fun<nm::EW_ADD, int64_t, uint8_t>, fun<nm::EW_ADD, int64_t, int8_t>, fun<nm::EW_ADD, int64_t, int16_t>, fun<nm::EW_ADD, int64_t, int32_t>, fun<nm::EW_ADD, int64_t, int64_t>, \
fun<nm::EW_ADD, int64_t, float32_t>, fun<nm::EW_ADD, int64_t, float64_t>, fun<nm::EW_ADD, int64_t, nm::Complex64>, fun<nm::EW_ADD, int64_t, nm::Complex128>, \
NULL}, \
\
{fun<nm::EW_ADD, float32_t, uint8_t>, fun<nm::EW_ADD, float32_t, int8_t>, fun<nm::EW_ADD, float32_t, int16_t>, fun<nm::EW_ADD, float32_t, int32_t>, fun<nm::EW_ADD, float32_t, int64_t>, \
fun<nm::EW_ADD, float32_t, float32_t>, fun<nm::EW_ADD, float32_t, float64_t>, fun<nm::EW_ADD, float32_t, nm::Complex64>, fun<nm::EW_ADD, float32_t, nm::Complex128>, \
NULL}, \
\
{fun<nm::EW_ADD, float64_t, uint8_t>, fun<nm::EW_ADD, float64_t, int8_t>, fun<nm::EW_ADD, float64_t, int16_t>, fun<nm::EW_ADD, float64_t, int32_t>, fun<nm::EW_ADD, float64_t, int64_t>, \
fun<nm::EW_ADD, float64_t, float32_t>, fun<nm::EW_ADD, float64_t, float64_t>, fun<nm::EW_ADD, float64_t, nm::Complex64>, fun<nm::EW_ADD, float64_t, nm::Complex128>, \
NULL}, \
\
{fun<nm::EW_ADD, nm::Complex64, uint8_t>, fun<nm::EW_ADD, nm::Complex64, int8_t>, fun<nm::EW_ADD, nm::Complex64, int16_t>, fun<nm::EW_ADD, nm::Complex64, int32_t>, \
fun<nm::EW_ADD, nm::Complex64, int64_t>, fun<nm::EW_ADD, nm::Complex64, float32_t>, fun<nm::EW_ADD, nm::Complex64, float64_t>, fun<nm::EW_ADD, nm::Complex64, nm::Complex64>, \
fun<nm::EW_ADD, nm::Complex64, nm::Complex128>, \
NULL}, \
\
{fun<nm::EW_ADD, nm::Complex128, uint8_t>, fun<nm::EW_ADD, nm::Complex128, int8_t>, fun<nm::EW_ADD, nm::Complex128, int16_t>, fun<nm::EW_ADD, nm::Complex128, int32_t>, \
fun<nm::EW_ADD, nm::Complex128, int64_t>, fun<nm::EW_ADD, nm::Complex128, float32_t>, fun<nm::EW_ADD, nm::Complex128, float64_t>, fun<nm::EW_ADD, nm::Complex128, nm::Complex64>, \
fun<nm::EW_ADD, nm::Complex128, nm::Complex128>, \
NULL}, \
{NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, fun<nm::EW_ADD, nm::RubyObject, nm::RubyObject>} \
}, \
\
{ \
{fun<nm::EW_SUB, uint8_t, uint8_t>, fun<nm::EW_SUB, uint8_t, int8_t>, fun<nm::EW_SUB, uint8_t, int16_t>, fun<nm::EW_SUB, uint8_t, int32_t>, fun<nm::EW_SUB, uint8_t, int64_t>, \
fun<nm::EW_SUB, uint8_t, float32_t>, fun<nm::EW_SUB, uint8_t, float64_t>, fun<nm::EW_SUB, uint8_t, nm::Complex64>, fun<nm::EW_SUB, uint8_t, nm::Complex128>, \
NULL}, \
\
{fun<nm::EW_SUB, int8_t, uint8_t>, fun<nm::EW_SUB, int8_t, int8_t>, fun<nm::EW_SUB, int8_t, int16_t>, fun<nm::EW_SUB, int8_t, int32_t>, fun<nm::EW_SUB, int8_t, int64_t>, \
fun<nm::EW_SUB, int8_t, float32_t>, fun<nm::EW_SUB, int8_t, float64_t>, fun<nm::EW_SUB, int8_t, nm::Complex64>, fun<nm::EW_SUB, int8_t, nm::Complex128>, \
NULL}, \
\
{fun<nm::EW_SUB, int16_t, uint8_t>, fun<nm::EW_SUB, int16_t, int8_t>, fun<nm::EW_SUB, int16_t, int16_t>, fun<nm::EW_SUB, int16_t, int32_t>, fun<nm::EW_SUB, int16_t, int64_t>, \
fun<nm::EW_SUB, int16_t, float32_t>, fun<nm::EW_SUB, int16_t, float64_t>, fun<nm::EW_SUB, int16_t, nm::Complex64>, fun<nm::EW_SUB, int16_t, nm::Complex128>, \
NULL}, \
\
{fun<nm::EW_SUB, int32_t, uint8_t>, fun<nm::EW_SUB, int32_t, int8_t>, fun<nm::EW_SUB, int32_t, int16_t>, fun<nm::EW_SUB, int32_t, int32_t>, fun<nm::EW_SUB, int32_t, int64_t>, \
fun<nm::EW_SUB, int32_t, float32_t>, fun<nm::EW_SUB, int32_t, float64_t>, fun<nm::EW_SUB, int32_t, nm::Complex64>, fun<nm::EW_SUB, int32_t, nm::Complex128>, \
NULL}, \
\
{fun<nm::EW_SUB, int64_t, uint8_t>, fun<nm::EW_SUB, int64_t, int8_t>, fun<nm::EW_SUB, int64_t, int16_t>, fun<nm::EW_SUB, int64_t, int32_t>, fun<nm::EW_SUB, int64_t, int64_t>, \
fun<nm::EW_SUB, int64_t, float32_t>, fun<nm::EW_SUB, int64_t, float64_t>, fun<nm::EW_SUB, int64_t, nm::Complex64>, fun<nm::EW_SUB, int64_t, nm::Complex128>, \
NULL}, \
\
{fun<nm::EW_SUB, float32_t, uint8_t>, fun<nm::EW_SUB, float32_t, int8_t>, fun<nm::EW_SUB, float32_t, int16_t>, fun<nm::EW_SUB, float32_t, int32_t>, fun<nm::EW_SUB, float32_t, int64_t>, \
fun<nm::EW_SUB, float32_t, float32_t>, fun<nm::EW_SUB, float32_t, float64_t>, fun<nm::EW_SUB, float32_t, nm::Complex64>, fun<nm::EW_SUB, float32_t, nm::Complex128>, \
NULL}, \
\
{fun<nm::EW_SUB, float64_t, uint8_t>, fun<nm::EW_SUB, float64_t, int8_t>, fun<nm::EW_SUB, float64_t, int16_t>, fun<nm::EW_SUB, float64_t, int32_t>, fun<nm::EW_SUB, float64_t, int64_t>, \
fun<nm::EW_SUB, float64_t, float32_t>, fun<nm::EW_SUB, float64_t, float64_t>, fun<nm::EW_SUB, float64_t, nm::Complex64>, fun<nm::EW_SUB, float64_t, nm::Complex128>, \
NULL}, \
\
{fun<nm::EW_SUB, nm::Complex64, uint8_t>, fun<nm::EW_SUB, nm::Complex64, int8_t>, fun<nm::EW_SUB, nm::Complex64, int16_t>, fun<nm::EW_SUB, nm::Complex64, int32_t>, \
fun<nm::EW_SUB, nm::Complex64, int64_t>, fun<nm::EW_SUB, nm::Complex64, float32_t>, fun<nm::EW_SUB, nm::Complex64, float64_t>, fun<nm::EW_SUB, nm::Complex64, nm::Complex64>, \
fun<nm::EW_SUB, nm::Complex64, nm::Complex128>, \
NULL}, \
\
{fun<nm::EW_SUB, nm::Complex128, uint8_t>, fun<nm::EW_SUB, nm::Complex128, int8_t>, fun<nm::EW_SUB, nm::Complex128, int16_t>, fun<nm::EW_SUB, nm::Complex128, int32_t>, \
fun<nm::EW_SUB, nm::Complex128, int64_t>, fun<nm::EW_SUB, nm::Complex128, float32_t>, fun<nm::EW_SUB, nm::Complex128, float64_t>, fun<nm::EW_SUB, nm::Complex128, nm::Complex64>, \
fun<nm::EW_SUB, nm::Complex128, nm::Complex128>, \
\
{NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, fun<nm::EW_SUB, nm::RubyObject, nm::RubyObject>} \
}, \
\
{ \
{fun<nm::EW_MUL, uint8_t, uint8_t>, fun<nm::EW_MUL, uint8_t, int8_t>, fun<nm::EW_MUL, uint8_t, int16_t>, fun<nm::EW_MUL, uint8_t, int32_t>, fun<nm::EW_MUL, uint8_t, int64_t>, \
fun<nm::EW_MUL, uint8_t, float32_t>, fun<nm::EW_MUL, uint8_t, float64_t>, fun<nm::EW_MUL, uint8_t, nm::Complex64>, fun<nm::EW_MUL, uint8_t, nm::Complex128>, \
NULL}, \
\
{fun<nm::EW_MUL, int8_t, uint8_t>, fun<nm::EW_MUL, int8_t, int8_t>, fun<nm::EW_MUL, int8_t, int16_t>, fun<nm::EW_MUL, int8_t, int32_t>, fun<nm::EW_MUL, int8_t, int64_t>, \
fun<nm::EW_MUL, int8_t, float32_t>, fun<nm::EW_MUL, int8_t, float64_t>, fun<nm::EW_MUL, int8_t, nm::Complex64>, fun<nm::EW_MUL, int8_t, nm::Complex128>, \
NULL}, \
\
{fun<nm::EW_MUL, int16_t, uint8_t>, fun<nm::EW_MUL, int16_t, int8_t>, fun<nm::EW_MUL, int16_t, int16_t>, fun<nm::EW_MUL, int16_t, int32_t>, fun<nm::EW_MUL, int16_t, int64_t>, \
fun<nm::EW_MUL, int16_t, float32_t>, fun<nm::EW_MUL, int16_t, float64_t>, fun<nm::EW_MUL, int16_t, nm::Complex64>, fun<nm::EW_MUL, int16_t, nm::Complex128>, \
NULL}, \
\
{fun<nm::EW_MUL, int32_t, uint8_t>, fun<nm::EW_MUL, int32_t, int8_t>, fun<nm::EW_MUL, int32_t, int16_t>, fun<nm::EW_MUL, int32_t, int32_t>, fun<nm::EW_MUL, int32_t, int64_t>, \
fun<nm::EW_MUL, int32_t, float32_t>, fun<nm::EW_MUL, int32_t, float64_t>, fun<nm::EW_MUL, int32_t, nm::Complex64>, fun<nm::EW_MUL, int32_t, nm::Complex128>, \
NULL}, \
\
{fun<nm::EW_MUL, int64_t, uint8_t>, fun<nm::EW_MUL, int64_t, int8_t>, fun<nm::EW_MUL, int64_t, int16_t>, fun<nm::EW_MUL, int64_t, int32_t>, fun<nm::EW_MUL, int64_t, int64_t>, \
fun<nm::EW_MUL, int64_t, float32_t>, fun<nm::EW_MUL, int64_t, float64_t>, fun<nm::EW_MUL, int64_t, nm::Complex64>, fun<nm::EW_MUL, int64_t, nm::Complex128>, \
NULL}, \
\
{fun<nm::EW_MUL, float32_t, uint8_t>, fun<nm::EW_MUL, float32_t, int8_t>, fun<nm::EW_MUL, float32_t, int16_t>, fun<nm::EW_MUL, float32_t, int32_t>, fun<nm::EW_MUL, float32_t, int64_t>, \
fun<nm::EW_MUL, float32_t, float32_t>, fun<nm::EW_MUL, float32_t, float64_t>, fun<nm::EW_MUL, float32_t, nm::Complex64>, fun<nm::EW_MUL, float32_t, nm::Complex128>, \
NULL}, \
\
{fun<nm::EW_MUL, float64_t, uint8_t>, fun<nm::EW_MUL, float64_t, int8_t>, fun<nm::EW_MUL, float64_t, int16_t>, fun<nm::EW_MUL, float64_t, int32_t>, fun<nm::EW_MUL, float64_t, int64_t>, \
fun<nm::EW_MUL, float64_t, float32_t>, fun<nm::EW_MUL, float64_t, float64_t>, fun<nm::EW_MUL, float64_t, nm::Complex64>, fun<nm::EW_MUL, float64_t, nm::Complex128>, \
NULL}, \
\
{fun<nm::EW_MUL, nm::Complex64, uint8_t>, fun<nm::EW_MUL, nm::Complex64, int8_t>, fun<nm::EW_MUL, nm::Complex64, int16_t>, fun<nm::EW_MUL, nm::Complex64, int32_t>, \
fun<nm::EW_MUL, nm::Complex64, int64_t>, fun<nm::EW_MUL, nm::Complex64, float32_t>, fun<nm::EW_MUL, nm::Complex64, float64_t>, fun<nm::EW_MUL, nm::Complex64, nm::Complex64>, \
fun<nm::EW_MUL, nm::Complex64, nm::Complex128>, \
NULL}, \
\
{fun<nm::EW_MUL, nm::Complex128, uint8_t>, fun<nm::EW_MUL, nm::Complex128, int8_t>, fun<nm::EW_MUL, nm::Complex128, int16_t>, fun<nm::EW_MUL, nm::Complex128, int32_t>, \
fun<nm::EW_MUL, nm::Complex128, int64_t>, fun<nm::EW_MUL, nm::Complex128, float32_t>, fun<nm::EW_MUL, nm::Complex128, float64_t>, fun<nm::EW_MUL, nm::Complex128, nm::Complex64>, \
fun<nm::EW_MUL, nm::Complex128, nm::Complex128>, \
\
{ \
{fun<nm::EW_DIV, uint8_t, uint8_t>, fun<nm::EW_DIV, uint8_t, int8_t>, fun<nm::EW_DIV, uint8_t, int16_t>, fun<nm::EW_DIV, uint8_t, int32_t>, fun<nm::EW_DIV, uint8_t, int64_t>, \
fun<nm::EW_DIV, uint8_t, float32_t>, fun<nm::EW_DIV, uint8_t, float64_t>, fun<nm::EW_DIV, uint8_t, nm::Complex64>, fun<nm::EW_DIV, uint8_t, nm::Complex128>, \
NULL}, \
\
{fun<nm::EW_DIV, int8_t, uint8_t>, fun<nm::EW_DIV, int8_t, int8_t>, fun<nm::EW_DIV, int8_t, int16_t>, fun<nm::EW_DIV, int8_t, int32_t>, fun<nm::EW_DIV, int8_t, int64_t>, \
fun<nm::EW_DIV, int8_t, float32_t>, fun<nm::EW_DIV, int8_t, float64_t>, fun<nm::EW_DIV, int8_t, nm::Complex64>, fun<nm::EW_DIV, int8_t, nm::Complex128>, \
NULL}, \
\
{fun<nm::EW_DIV, int16_t, uint8_t>, fun<nm::EW_DIV, int16_t, int8_t>, fun<nm::EW_DIV, int16_t, int16_t>, fun<nm::EW_DIV, int16_t, int32_t>, fun<nm::EW_DIV, int16_t, int64_t>, \
fun<nm::EW_DIV, int16_t, float32_t>, fun<nm::EW_DIV, int16_t, float64_t>, fun<nm::EW_DIV, int16_t, nm::Complex64>, fun<nm::EW_DIV, int16_t, nm::Complex128>, \
NULL}, \
\
{fun<nm::EW_DIV, int32_t, uint8_t>, fun<nm::EW_DIV, int32_t, int8_t>, fun<nm::EW_DIV, int32_t, int16_t>, fun<nm::EW_DIV, int32_t, int32_t>, fun<nm::EW_DIV, int32_t, int64_t>, \
fun<nm::EW_DIV, int32_t, float32_t>, fun<nm::EW_DIV, int32_t, float64_t>, fun<nm::EW_DIV, int32_t, nm::Complex64>, fun<nm::EW_DIV, int32_t, nm::Complex128>, \
NULL}, \
\
{fun<nm::EW_DIV, int64_t, uint8_t>, fun<nm::EW_DIV, int64_t, int8_t>, fun<nm::EW_DIV, int64_t, int16_t>, fun<nm::EW_DIV, int64_t, int32_t>, fun<nm::EW_DIV, int64_t, int64_t>, \
fun<nm::EW_DIV, int64_t, float32_t>, fun<nm::EW_DIV, int64_t, float64_t>, fun<nm::EW_DIV, int64_t, nm::Complex64>, fun<nm::EW_DIV, int64_t, nm::Complex128>, \
NULL}, \
\
{fun<nm::EW_DIV, float32_t, uint8_t>, fun<nm::EW_DIV, float32_t, int8_t>, fun<nm::EW_DIV, float32_t, int16_t>, fun<nm::EW_DIV, float32_t, int32_t>, fun<nm::EW_DIV, float32_t, int64_t>, \
fun<nm::EW_DIV, float32_t, float32_t>, fun<nm::EW_DIV, float32_t, float64_t>, fun<nm::EW_DIV, float32_t, nm::Complex64>, fun<nm::EW_DIV, float32_t, nm::Complex128>, \
NULL}, \
\
{fun<nm::EW_DIV, float64_t, uint8_t>, fun<nm::EW_DIV, float64_t, int8_t>, fun<nm::EW_DIV, float64_t, int16_t>, fun<nm::EW_DIV, float64_t, int32_t>, fun<nm::EW_DIV, float64_t, int64_t>, \
fun<nm::EW_DIV, float64_t, float32_t>, fun<nm::EW_DIV, float64_t, float64_t>, fun<nm::EW_DIV, float64_t, nm::Complex64>, fun<nm::EW_DIV, float64_t, nm::Complex128>, \
NULL}, \
\
{fun<nm::EW_DIV, nm::Complex64, uint8_t>, fun<nm::EW_DIV, nm::Complex64, int8_t>, fun<nm::EW_DIV, nm::Complex64, int16_t>, fun<nm::EW_DIV, nm::Complex64, int32_t>, \
fun<nm::EW_DIV, nm::Complex64, int64_t>, fun<nm::EW_DIV, nm::Complex64, float32_t>, fun<nm::EW_DIV, nm::Complex64, float64_t>, fun<nm::EW_DIV, nm::Complex64, nm::Complex64>, \
fun<nm::EW_DIV, nm::Complex64, nm::Complex128>, \
NULL}, \
\
{fun<nm::EW_DIV, nm::Complex128, uint8_t>, fun<nm::EW_DIV, nm::Complex128, int8_t>, fun<nm::EW_DIV, nm::Complex128, int16_t>, fun<nm::EW_DIV, nm::Complex128, int32_t>, \
fun<nm::EW_DIV, nm::Complex128, int64_t>, fun<nm::EW_DIV, nm::Complex128, float32_t>, fun<nm::EW_DIV, nm::Complex128, float64_t>, fun<nm::EW_DIV, nm::Complex128, nm::Complex64>, \
fun<nm::EW_DIV, nm::Complex128, nm::Complex128>, \
NULL}, \
\
{NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, fun<nm::EW_DIV, nm::RubyObject, nm::RubyObject>} \
}, \
\
{ \
{fun<nm::EW_POW, uint8_t, uint8_t>, fun<nm::EW_POW, uint8_t, int8_t>, fun<nm::EW_POW, uint8_t, int16_t>, fun<nm::EW_POW, uint8_t, int32_t>, fun<nm::EW_POW, uint8_t, int64_t>, \
fun<nm::EW_POW, uint8_t, float32_t>, fun<nm::EW_POW, uint8_t, float64_t>, fun<nm::EW_POW, uint8_t, nm::Complex64>, fun<nm::EW_POW, uint8_t, nm::Complex128>, \
NULL}, \
\
{fun<nm::EW_POW, int8_t, uint8_t>, fun<nm::EW_POW, int8_t, int8_t>, fun<nm::EW_POW, int8_t, int16_t>, fun<nm::EW_POW, int8_t, int32_t>, fun<nm::EW_POW, int8_t, int64_t>, \
fun<nm::EW_POW, int8_t, float32_t>, fun<nm::EW_POW, int8_t, float64_t>, fun<nm::EW_POW, int8_t, nm::Complex64>, fun<nm::EW_POW, int8_t, nm::Complex128>, \
NULL}, \
\
{fun<nm::EW_POW, int16_t, uint8_t>, fun<nm::EW_POW, int16_t, int8_t>, fun<nm::EW_POW, int16_t, int16_t>, fun<nm::EW_POW, int16_t, int32_t>, fun<nm::EW_POW, int16_t, int64_t>, \
fun<nm::EW_POW, int16_t, float32_t>, fun<nm::EW_POW, int16_t, float64_t>, fun<nm::EW_POW, int16_t, nm::Complex64>, fun<nm::EW_POW, int16_t, nm::Complex128>, \
NULL}, \
\
{fun<nm::EW_POW, int32_t, uint8_t>, fun<nm::EW_POW, int32_t, int8_t>, fun<nm::EW_POW, int32_t, int16_t>, fun<nm::EW_POW, int32_t, int32_t>, fun<nm::EW_POW, int32_t, int64_t>, \
fun<nm::EW_POW, int32_t, float32_t>, fun<nm::EW_POW, int32_t, float64_t>, fun<nm::EW_POW, int32_t, nm::Complex64>, fun<nm::EW_POW, int32_t, nm::Complex128>, \
NULL}, \
\
{fun<nm::EW_POW, int64_t, uint8_t>, fun<nm::EW_POW, int64_t, int8_t>, fun<nm::EW_POW, int64_t, int16_t>, fun<nm::EW_POW, int64_t, int32_t>, fun<nm::EW_POW, int64_t, int64_t>, \
fun<nm::EW_POW, int64_t, float32_t>, fun<nm::EW_POW, int64_t, float64_t>, fun<nm::EW_POW, int64_t, nm::Complex64>, fun<nm::EW_POW, int64_t, nm::Complex128>, \
NULL}, \
\
{fun<nm::EW_POW, float32_t, uint8_t>, fun<nm::EW_POW, float32_t, int8_t>, fun<nm::EW_POW, float32_t, int16_t>, fun<nm::EW_POW, float32_t, int32_t>, fun<nm::EW_POW, float32_t, int64_t>, \
fun<nm::EW_POW, float32_t, float32_t>, fun<nm::EW_POW, float32_t, float64_t>, fun<nm::EW_POW, float32_t, nm::Complex64>, fun<nm::EW_POW, float32_t, nm::Complex128>, \
NULL}, \
\
{fun<nm::EW_POW, float64_t, uint8_t>, fun<nm::EW_POW, float64_t, int8_t>, fun<nm::EW_POW, float64_t, int16_t>, fun<nm::EW_POW, float64_t, int32_t>, fun<nm::EW_POW, float64_t, int64_t>, \
fun<nm::EW_POW, float64_t, float32_t>, fun<nm::EW_POW, float64_t, float64_t>, fun<nm::EW_POW, float64_t, nm::Complex64>, fun<nm::EW_POW, float64_t, nm::Complex128>, \
NULL}, \
\
{fun<nm::EW_POW, nm::Complex64, uint8_t>, fun<nm::EW_POW, nm::Complex64, int8_t>, fun<nm::EW_POW, nm::Complex64, int16_t>, fun<nm::EW_POW, nm::Complex64, int32_t>, \
fun<nm::EW_POW, nm::Complex64, int64_t>, fun<nm::EW_POW, nm::Complex64, float32_t>, fun<nm::EW_POW, nm::Complex64, float64_t>, fun<nm::EW_POW, nm::Complex64, nm::Complex64>, \
fun<nm::EW_POW, nm::Complex64, nm::Complex128>, \
NULL}, \
\
{fun<nm::EW_POW, nm::Complex128, uint8_t>, fun<nm::EW_POW, nm::Complex128, int8_t>, fun<nm::EW_POW, nm::Complex128, int16_t>, fun<nm::EW_POW, nm::Complex128, int32_t>, \
fun<nm::EW_POW, nm::Complex128, int64_t>, fun<nm::EW_POW, nm::Complex128, float32_t>, fun<nm::EW_POW, nm::Complex128, float64_t>, fun<nm::EW_POW, nm::Complex128, nm::Complex64>, \
fun<nm::EW_POW, nm::Complex128, nm::Complex128>, \
NULL}, \
\
{NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, fun<nm::EW_POW, nm::RubyObject, nm::RubyObject>} \
}, \
\
{ \
{fun<nm::EW_MOD, uint8_t, uint8_t>, fun<nm::EW_MOD, uint8_t, int8_t>, fun<nm::EW_MOD, uint8_t, int16_t>, fun<nm::EW_MOD, uint8_t, int32_t>, fun<nm::EW_MOD, uint8_t, int64_t>, \
fun<nm::EW_MOD, uint8_t, float32_t>, fun<nm::EW_MOD, uint8_t, float64_t>, fun<nm::EW_MOD, uint8_t, nm::Complex64>, fun<nm::EW_MOD, uint8_t, nm::Complex128>, \
NULL}, \
\
{fun<nm::EW_MOD, int8_t, uint8_t>, fun<nm::EW_MOD, int8_t, int8_t>, fun<nm::EW_MOD, int8_t, int16_t>, fun<nm::EW_MOD, int8_t, int32_t>, fun<nm::EW_MOD, int8_t, int64_t>, \
fun<nm::EW_MOD, int8_t, float32_t>, fun<nm::EW_MOD, int8_t, float64_t>, fun<nm::EW_MOD, int8_t, nm::Complex64>, fun<nm::EW_MOD, int8_t, nm::Complex128>, \
NULL}, \
\
{fun<nm::EW_MOD, int16_t, uint8_t>, fun<nm::EW_MOD, int16_t, int8_t>, fun<nm::EW_MOD, int16_t, int16_t>, fun<nm::EW_MOD, int16_t, int32_t>, fun<nm::EW_MOD, int16_t, int64_t>, \
fun<nm::EW_MOD, int16_t, float32_t>, fun<nm::EW_MOD, int16_t, float64_t>, fun<nm::EW_MOD, int16_t, nm::Complex64>, fun<nm::EW_MOD, int16_t, nm::Complex128>, \
NULL}, \
\
{fun<nm::EW_MOD, int32_t, uint8_t>, fun<nm::EW_MOD, int32_t, int8_t>, fun<nm::EW_MOD, int32_t, int16_t>, fun<nm::EW_MOD, int32_t, int32_t>, fun<nm::EW_MOD, int32_t, int64_t>, \
fun<nm::EW_MOD, int32_t, float32_t>, fun<nm::EW_MOD, int32_t, float64_t>, fun<nm::EW_MOD, int32_t, nm::Complex64>, fun<nm::EW_MOD, int32_t, nm::Complex128>, \
NULL}, \
\
{fun<nm::EW_MOD, int64_t, uint8_t>, fun<nm::EW_MOD, int64_t, int8_t>, fun<nm::EW_MOD, int64_t, int16_t>, fun<nm::EW_MOD, int64_t, int32_t>, fun<nm::EW_MOD, int64_t, int64_t>, \
fun<nm::EW_MOD, int64_t, float32_t>, fun<nm::EW_MOD, int64_t, float64_t>, fun<nm::EW_MOD, int64_t, nm::Complex64>, fun<nm::EW_MOD, int64_t, nm::Complex128>, \
NULL}, \
\
{fun<nm::EW_MOD, float32_t, uint8_t>, fun<nm::EW_MOD, float32_t, int8_t>, fun<nm::EW_MOD, float32_t, int16_t>, fun<nm::EW_MOD, float32_t, int32_t>, fun<nm::EW_MOD, float32_t, int64_t>, \
fun<nm::EW_MOD, float32_t, float32_t>, fun<nm::EW_MOD, float32_t, float64_t>, fun<nm::EW_MOD, float32_t, nm::Complex64>, fun<nm::EW_MOD, float32_t, nm::Complex128>, \
NULL}, \
\
{fun<nm::EW_MOD, float64_t, uint8_t>, fun<nm::EW_MOD, float64_t, int8_t>, fun<nm::EW_MOD, float64_t, int16_t>, fun<nm::EW_MOD, float64_t, int32_t>, fun<nm::EW_MOD, float64_t, int64_t>, \
fun<nm::EW_MOD, float64_t, float32_t>, fun<nm::EW_MOD, float64_t, float64_t>, fun<nm::EW_MOD, float64_t, nm::Complex64>, fun<nm::EW_MOD, float64_t, nm::Complex128>, \
NULL}, \
\
{fun<nm::EW_MOD, nm::Complex64, uint8_t>, fun<nm::EW_MOD, nm::Complex64, int8_t>, fun<nm::EW_MOD, nm::Complex64, int16_t>, fun<nm::EW_MOD, nm::Complex64, int32_t>, \
fun<nm::EW_MOD, nm::Complex64, int64_t>, fun<nm::EW_MOD, nm::Complex64, float32_t>, fun<nm::EW_MOD, nm::Complex64, float64_t>, fun<nm::EW_MOD, nm::Complex64, nm::Complex64>, \
fun<nm::EW_MOD, nm::Complex64, nm::Complex128>, \
NULL}, \
\
{fun<nm::EW_MOD, nm::Complex128, uint8_t>, fun<nm::EW_MOD, nm::Complex128, int8_t>, fun<nm::EW_MOD, nm::Complex128, int16_t>, fun<nm::EW_MOD, nm::Complex128, int32_t>, \
fun<nm::EW_MOD, nm::Complex128, int64_t>, fun<nm::EW_MOD, nm::Complex128, float32_t>, fun<nm::EW_MOD, nm::Complex128, float64_t>, fun<nm::EW_MOD, nm::Complex128, nm::Complex64>, \
fun<nm::EW_MOD, nm::Complex128, nm::Complex128>, \
NULL}, \
\
{NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, fun<nm::EW_MOD, nm::RubyObject, nm::RubyObject>} \
}, \
\
{ \
{fun<nm::EW_EQEQ, uint8_t, uint8_t>, fun<nm::EW_EQEQ, uint8_t, int8_t>, fun<nm::EW_EQEQ, uint8_t, int16_t>, fun<nm::EW_EQEQ, uint8_t, int32_t>, \
fun<nm::EW_EQEQ, uint8_t, int64_t>, fun<nm::EW_EQEQ, uint8_t, float32_t>, fun<nm::EW_EQEQ, uint8_t, float64_t>, fun<nm::EW_EQEQ, uint8_t, nm::Complex64>, \
fun<nm::EW_EQEQ, uint8_t, nm::Complex128>, \
NULL}, \
{fun<nm::EW_EQEQ, int8_t, uint8_t>, fun<nm::EW_EQEQ, int8_t, int8_t>, fun<nm::EW_EQEQ, int8_t, int16_t>, fun<nm::EW_EQEQ, int8_t, int32_t>, fun<nm::EW_EQEQ, int8_t, int64_t>, fun<nm::EW_EQEQ, int8_t, float32_t>, fun<nm::EW_EQEQ, int8_t, float64_t>, fun<nm::EW_EQEQ, int8_t, nm::Complex64>, fun<nm::EW_EQEQ, int8_t, nm::Complex128>, NULL}, \
{fun<nm::EW_EQEQ, int16_t, uint8_t>, fun<nm::EW_EQEQ, int16_t, int8_t>, fun<nm::EW_EQEQ, int16_t, int16_t>, fun<nm::EW_EQEQ, int16_t, int32_t>, fun<nm::EW_EQEQ, int16_t, int64_t>, fun<nm::EW_EQEQ, int16_t, float32_t>, fun<nm::EW_EQEQ, int16_t, float64_t>, fun<nm::EW_EQEQ, int16_t, nm::Complex64>, fun<nm::EW_EQEQ, int16_t, nm::Complex128>, NULL}, \
{fun<nm::EW_EQEQ, int32_t, uint8_t>, fun<nm::EW_EQEQ, int32_t, int8_t>, fun<nm::EW_EQEQ, int32_t, int16_t>, fun<nm::EW_EQEQ, int32_t, int32_t>, fun<nm::EW_EQEQ, int32_t, int64_t>, fun<nm::EW_EQEQ, int32_t, float32_t>, fun<nm::EW_EQEQ, int32_t, float64_t>, fun<nm::EW_EQEQ, int32_t, nm::Complex64>, fun<nm::EW_EQEQ, int32_t, nm::Complex128>, NULL}, \
{fun<nm::EW_EQEQ, int64_t, uint8_t>, fun<nm::EW_EQEQ, int64_t, int8_t>, fun<nm::EW_EQEQ, int64_t, int16_t>, fun<nm::EW_EQEQ, int64_t, int32_t>, fun<nm::EW_EQEQ, int64_t, int64_t>, fun<nm::EW_EQEQ, int64_t, float32_t>, fun<nm::EW_EQEQ, int64_t, float64_t>, fun<nm::EW_EQEQ, int64_t, nm::Complex64>, fun<nm::EW_EQEQ, int64_t, nm::Complex128>, NULL}, \
{fun<nm::EW_EQEQ, float32_t, uint8_t>, fun<nm::EW_EQEQ, float32_t, int8_t>, fun<nm::EW_EQEQ, float32_t, int16_t>, fun<nm::EW_EQEQ, float32_t, int32_t>, fun<nm::EW_EQEQ, float32_t, int64_t>, fun<nm::EW_EQEQ, float32_t, float32_t>, fun<nm::EW_EQEQ, float32_t, float64_t>, fun<nm::EW_EQEQ, float32_t, nm::Complex64>, fun<nm::EW_EQEQ, float32_t, nm::Complex128>, NULL}, \
{fun<nm::EW_EQEQ, float64_t, uint8_t>, fun<nm::EW_EQEQ, float64_t, int8_t>, fun<nm::EW_EQEQ, float64_t, int16_t>, fun<nm::EW_EQEQ, float64_t, int32_t>, fun<nm::EW_EQEQ, float64_t, int64_t>, fun<nm::EW_EQEQ, float64_t, float32_t>, fun<nm::EW_EQEQ, float64_t, float64_t>, fun<nm::EW_EQEQ, float64_t, nm::Complex64>, fun<nm::EW_EQEQ, float64_t, nm::Complex128>, NULL}, \
{fun<nm::EW_EQEQ, nm::Complex64, uint8_t>, fun<nm::EW_EQEQ, nm::Complex64, int8_t>, fun<nm::EW_EQEQ, nm::Complex64, int16_t>, fun<nm::EW_EQEQ, nm::Complex64, int32_t>, fun<nm::EW_EQEQ, nm::Complex64, int64_t>, fun<nm::EW_EQEQ, nm::Complex64, float32_t>, fun<nm::EW_EQEQ, nm::Complex64, float64_t>, fun<nm::EW_EQEQ, nm::Complex64, nm::Complex64>, fun<nm::EW_EQEQ, nm::Complex64, nm::Complex128>, NULL}, \
{fun<nm::EW_EQEQ, nm::Complex128, uint8_t>, fun<nm::EW_EQEQ, nm::Complex128, int8_t>, fun<nm::EW_EQEQ, nm::Complex128, int16_t>, fun<nm::EW_EQEQ, nm::Complex128, int32_t>, fun<nm::EW_EQEQ, nm::Complex128, int64_t>, fun<nm::EW_EQEQ, nm::Complex128, float32_t>, fun<nm::EW_EQEQ, nm::Complex128, float64_t>, fun<nm::EW_EQEQ, nm::Complex128, nm::Complex64>, fun<nm::EW_EQEQ, nm::Complex128, nm::Complex128>, NULL}, \
{NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, fun<nm::EW_EQEQ, nm::RubyObject, nm::RubyObject>} \
}, \
{{fun<nm::EW_NEQ, uint8_t, uint8_t>, fun<nm::EW_NEQ, uint8_t, int8_t>, fun<nm::EW_NEQ, uint8_t, int16_t>, fun<nm::EW_NEQ, uint8_t, int32_t>, fun<nm::EW_NEQ, uint8_t, int64_t>, fun<nm::EW_NEQ, uint8_t, float32_t>, fun<nm::EW_NEQ, uint8_t, float64_t>, fun<nm::EW_NEQ, uint8_t, nm::Complex64>, fun<nm::EW_NEQ, uint8_t, nm::Complex128>, NULL}, \
{fun<nm::EW_NEQ, int8_t, uint8_t>, fun<nm::EW_NEQ, int8_t, int8_t>, fun<nm::EW_NEQ, int8_t, int16_t>, fun<nm::EW_NEQ, int8_t, int32_t>, fun<nm::EW_NEQ, int8_t, int64_t>, fun<nm::EW_NEQ, int8_t, float32_t>, fun<nm::EW_NEQ, int8_t, float64_t>, fun<nm::EW_NEQ, int8_t, nm::Complex64>, fun<nm::EW_NEQ, int8_t, nm::Complex128>, NULL}, \
{fun<nm::EW_NEQ, int16_t, uint8_t>, fun<nm::EW_NEQ, int16_t, int8_t>, fun<nm::EW_NEQ, int16_t, int16_t>, fun<nm::EW_NEQ, int16_t, int32_t>, fun<nm::EW_NEQ, int16_t, int64_t>, fun<nm::EW_NEQ, int16_t, float32_t>, fun<nm::EW_NEQ, int16_t, float64_t>, fun<nm::EW_NEQ, int16_t, nm::Complex64>, fun<nm::EW_NEQ, int16_t, nm::Complex128>, NULL}, \
{fun<nm::EW_NEQ, int32_t, uint8_t>, fun<nm::EW_NEQ, int32_t, int8_t>, fun<nm::EW_NEQ, int32_t, int16_t>, fun<nm::EW_NEQ, int32_t, int32_t>, fun<nm::EW_NEQ, int32_t, int64_t>, fun<nm::EW_NEQ, int32_t, float32_t>, fun<nm::EW_NEQ, int32_t, float64_t>, fun<nm::EW_NEQ, int32_t, nm::Complex64>, fun<nm::EW_NEQ, int32_t, nm::Complex128>, NULL}, \
{fun<nm::EW_NEQ, int64_t, uint8_t>, fun<nm::EW_NEQ, int64_t, int8_t>, fun<nm::EW_NEQ, int64_t, int16_t>, fun<nm::EW_NEQ, int64_t, int32_t>, fun<nm::EW_NEQ, int64_t, int64_t>, fun<nm::EW_NEQ, int64_t, float32_t>, fun<nm::EW_NEQ, int64_t, float64_t>, fun<nm::EW_NEQ, int64_t, nm::Complex64>, fun<nm::EW_NEQ, int64_t, nm::Complex128>, NULL}, \
{fun<nm::EW_NEQ, float32_t, uint8_t>, fun<nm::EW_NEQ, float32_t, int8_t>, fun<nm::EW_NEQ, float32_t, int16_t>, fun<nm::EW_NEQ, float32_t, int32_t>, fun<nm::EW_NEQ, float32_t, int64_t>, fun<nm::EW_NEQ, float32_t, float32_t>, fun<nm::EW_NEQ, float32_t, float64_t>, fun<nm::EW_NEQ, float32_t, nm::Complex64>, fun<nm::EW_NEQ, float32_t, nm::Complex128>, NULL}, \
{fun<nm::EW_NEQ, float64_t, uint8_t>, fun<nm::EW_NEQ, float64_t, int8_t>, fun<nm::EW_NEQ, float64_t, int16_t>, fun<nm::EW_NEQ, float64_t, int32_t>, fun<nm::EW_NEQ, float64_t, int64_t>, fun<nm::EW_NEQ, float64_t, float32_t>, fun<nm::EW_NEQ, float64_t, float64_t>, fun<nm::EW_NEQ, float64_t, nm::Complex64>, fun<nm::EW_NEQ, float64_t, nm::Complex128>, NULL}, \
{fun<nm::EW_NEQ, nm::Complex64, uint8_t>, fun<nm::EW_NEQ, nm::Complex64, int8_t>, fun<nm::EW_NEQ, nm::Complex64, int16_t>, fun<nm::EW_NEQ, nm::Complex64, int32_t>, fun<nm::EW_NEQ, nm::Complex64, int64_t>, fun<nm::EW_NEQ, nm::Complex64, float32_t>, fun<nm::EW_NEQ, nm::Complex64, float64_t>, fun<nm::EW_NEQ, nm::Complex64, nm::Complex64>, fun<nm::EW_NEQ, nm::Complex64, nm::Complex128>, NULL}, \
{fun<nm::EW_NEQ, nm::Complex128, uint8_t>, fun<nm::EW_NEQ, nm::Complex128, int8_t>, fun<nm::EW_NEQ, nm::Complex128, int16_t>, fun<nm::EW_NEQ, nm::Complex128, int32_t>, fun<nm::EW_NEQ, nm::Complex128, int64_t>, fun<nm::EW_NEQ, nm::Complex128, float32_t>, fun<nm::EW_NEQ, nm::Complex128, float64_t>, fun<nm::EW_NEQ, nm::Complex128, nm::Complex64>, fun<nm::EW_NEQ, nm::Complex128, nm::Complex128>, NULL}, \
{NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, fun<nm::EW_NEQ, nm::RubyObject, nm::RubyObject>}}, \
{{fun<nm::EW_LT, uint8_t, uint8_t>, fun<nm::EW_LT, uint8_t, int8_t>, fun<nm::EW_LT, uint8_t, int16_t>, fun<nm::EW_LT, uint8_t, int32_t>, fun<nm::EW_LT, uint8_t, int64_t>, fun<nm::EW_LT, uint8_t, float32_t>, fun<nm::EW_LT, uint8_t, float64_t>, fun<nm::EW_LT, uint8_t, nm::Complex64>, fun<nm::EW_LT, uint8_t, nm::Complex128>, NULL}, \
{fun<nm::EW_LT, int8_t, uint8_t>, fun<nm::EW_LT, int8_t, int8_t>, fun<nm::EW_LT, int8_t, int16_t>, fun<nm::EW_LT, int8_t, int32_t>, fun<nm::EW_LT, int8_t, int64_t>, fun<nm::EW_LT, int8_t, float32_t>, fun<nm::EW_LT, int8_t, float64_t>, fun<nm::EW_LT, int8_t, nm::Complex64>, fun<nm::EW_LT, int8_t, nm::Complex128>, NULL}, \
{fun<nm::EW_LT, int16_t, uint8_t>, fun<nm::EW_LT, int16_t, int8_t>, fun<nm::EW_LT, int16_t, int16_t>, fun<nm::EW_LT, int16_t, int32_t>, fun<nm::EW_LT, int16_t, int64_t>, fun<nm::EW_LT, int16_t, float32_t>, fun<nm::EW_LT, int16_t, float64_t>, fun<nm::EW_LT, int16_t, nm::Complex64>, fun<nm::EW_LT, int16_t, nm::Complex128>, NULL}, \
{fun<nm::EW_LT, int32_t, uint8_t>, fun<nm::EW_LT, int32_t, int8_t>, fun<nm::EW_LT, int32_t, int16_t>, fun<nm::EW_LT, int32_t, int32_t>, fun<nm::EW_LT, int32_t, int64_t>, fun<nm::EW_LT, int32_t, float32_t>, fun<nm::EW_LT, int32_t, float64_t>, fun<nm::EW_LT, int32_t, nm::Complex64>, fun<nm::EW_LT, int32_t, nm::Complex128>, NULL}, \
{fun<nm::EW_LT, int64_t, uint8_t>, fun<nm::EW_LT, int64_t, int8_t>, fun<nm::EW_LT, int64_t, int16_t>, fun<nm::EW_LT, int64_t, int32_t>, fun<nm::EW_LT, int64_t, int64_t>, fun<nm::EW_LT, int64_t, float32_t>, fun<nm::EW_LT, int64_t, float64_t>, fun<nm::EW_LT, int64_t, nm::Complex64>, fun<nm::EW_LT, int64_t, nm::Complex128>, NULL}, \
{fun<nm::EW_LT, float32_t, uint8_t>, fun<nm::EW_LT, float32_t, int8_t>, fun<nm::EW_LT, float32_t, int16_t>, fun<nm::EW_LT, float32_t, int32_t>, fun<nm::EW_LT, float32_t, int64_t>, fun<nm::EW_LT, float32_t, float32_t>, fun<nm::EW_LT, float32_t, float64_t>, fun<nm::EW_LT, float32_t, nm::Complex64>, fun<nm::EW_LT, float32_t, nm::Complex128>, NULL}, \
{fun<nm::EW_LT, float64_t, uint8_t>, fun<nm::EW_LT, float64_t, int8_t>, fun<nm::EW_LT, float64_t, int16_t>, fun<nm::EW_LT, float64_t, int32_t>, fun<nm::EW_LT, float64_t, int64_t>, fun<nm::EW_LT, float64_t, float32_t>, fun<nm::EW_LT, float64_t, float64_t>, fun<nm::EW_LT, float64_t, nm::Complex64>, fun<nm::EW_LT, float64_t, nm::Complex128>, NULL}, \
{fun<nm::EW_LT, nm::Complex64, uint8_t>, fun<nm::EW_LT, nm::Complex64, int8_t>, fun<nm::EW_LT, nm::Complex64, int16_t>, fun<nm::EW_LT, nm::Complex64, int32_t>, fun<nm::EW_LT, nm::Complex64, int64_t>, fun<nm::EW_LT, nm::Complex64, float32_t>, fun<nm::EW_LT, nm::Complex64, float64_t>, fun<nm::EW_LT, nm::Complex64, nm::Complex64>, fun<nm::EW_LT, nm::Complex64, nm::Complex128>, NULL}, \
{fun<nm::EW_LT, nm::Complex128, uint8_t>, fun<nm::EW_LT, nm::Complex128, int8_t>, fun<nm::EW_LT, nm::Complex128, int16_t>, fun<nm::EW_LT, nm::Complex128, int32_t>, fun<nm::EW_LT, nm::Complex128, int64_t>, fun<nm::EW_LT, nm::Complex128, float32_t>, fun<nm::EW_LT, nm::Complex128, float64_t>, fun<nm::EW_LT, nm::Complex128, nm::Complex64>, fun<nm::EW_LT, nm::Complex128, nm::Complex128>, NULL}, \
{NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, fun<nm::EW_LT, nm::RubyObject, nm::RubyObject>}}, \
{{fun<nm::EW_GT, uint8_t, uint8_t>, fun<nm::EW_GT, uint8_t, int8_t>, fun<nm::EW_GT, uint8_t, int16_t>, fun<nm::EW_GT, uint8_t, int32_t>, fun<nm::EW_GT, uint8_t, int64_t>, fun<nm::EW_GT, uint8_t, float32_t>, fun<nm::EW_GT, uint8_t, float64_t>, fun<nm::EW_GT, uint8_t, nm::Complex64>, fun<nm::EW_GT, uint8_t, nm::Complex128>, NULL}, \
{fun<nm::EW_GT, int8_t, uint8_t>, fun<nm::EW_GT, int8_t, int8_t>, fun<nm::EW_GT, int8_t, int16_t>, fun<nm::EW_GT, int8_t, int32_t>, fun<nm::EW_GT, int8_t, int64_t>, fun<nm::EW_GT, int8_t, float32_t>, fun<nm::EW_GT, int8_t, float64_t>, fun<nm::EW_GT, int8_t, nm::Complex64>, fun<nm::EW_GT, int8_t, nm::Complex128>, NULL}, \
{fun<nm::EW_GT, int16_t, uint8_t>, fun<nm::EW_GT, int16_t, int8_t>, fun<nm::EW_GT, int16_t, int16_t>, fun<nm::EW_GT, int16_t, int32_t>, fun<nm::EW_GT, int16_t, int64_t>, fun<nm::EW_GT, int16_t, float32_t>, fun<nm::EW_GT, int16_t, float64_t>, fun<nm::EW_GT, int16_t, nm::Complex64>, fun<nm::EW_GT, int16_t, nm::Complex128>, NULL}, \
{fun<nm::EW_GT, int32_t, uint8_t>, fun<nm::EW_GT, int32_t, int8_t>, fun<nm::EW_GT, int32_t, int16_t>, fun<nm::EW_GT, int32_t, int32_t>, fun<nm::EW_GT, int32_t, int64_t>, fun<nm::EW_GT, int32_t, float32_t>, fun<nm::EW_GT, int32_t, float64_t>, fun<nm::EW_GT, int32_t, nm::Complex64>, fun<nm::EW_GT, int32_t, nm::Complex128>, NULL}, \
{fun<nm::EW_GT, int64_t, uint8_t>, fun<nm::EW_GT, int64_t, int8_t>, fun<nm::EW_GT, int64_t, int16_t>, fun<nm::EW_GT, int64_t, int32_t>, fun<nm::EW_GT, int64_t, int64_t>, fun<nm::EW_GT, int64_t, float32_t>, fun<nm::EW_GT, int64_t, float64_t>, fun<nm::EW_GT, int64_t, nm::Complex64>, fun<nm::EW_GT, int64_t, nm::Complex128>, NULL}, \
{fun<nm::EW_GT, float32_t, uint8_t>, fun<nm::EW_GT, float32_t, int8_t>, fun<nm::EW_GT, float32_t, int16_t>, fun<nm::EW_GT, float32_t, int32_t>, fun<nm::EW_GT, float32_t, int64_t>, fun<nm::EW_GT, float32_t, float32_t>, fun<nm::EW_GT, float32_t, float64_t>, fun<nm::EW_GT, float32_t, nm::Complex64>, fun<nm::EW_GT, float32_t, nm::Complex128>, NULL}, \
{fun<nm::EW_GT, float64_t, uint8_t>, fun<nm::EW_GT, float64_t, int8_t>, fun<nm::EW_GT, float64_t, int16_t>, fun<nm::EW_GT, float64_t, int32_t>, fun<nm::EW_GT, float64_t, int64_t>, fun<nm::EW_GT, float64_t, float32_t>, fun<nm::EW_GT, float64_t, float64_t>, fun<nm::EW_GT, float64_t, nm::Complex64>, fun<nm::EW_GT, float64_t, nm::Complex128>, NULL}, \
{fun<nm::EW_GT, nm::Complex64, uint8_t>, fun<nm::EW_GT, nm::Complex64, int8_t>, fun<nm::EW_GT, nm::Complex64, int16_t>, fun<nm::EW_GT, nm::Complex64, int32_t>, fun<nm::EW_GT, nm::Complex64, int64_t>, fun<nm::EW_GT, nm::Complex64, float32_t>, fun<nm::EW_GT, nm::Complex64, float64_t>, fun<nm::EW_GT, nm::Complex64, nm::Complex64>, fun<nm::EW_GT, nm::Complex64, nm::Complex128>, NULL}, \
{fun<nm::EW_GT, nm::Complex128, uint8_t>, fun<nm::EW_GT, nm::Complex128, int8_t>, fun<nm::EW_GT, nm::Complex128, int16_t>, fun<nm::EW_GT, nm::Complex128, int32_t>, fun<nm::EW_GT, nm::Complex128, int64_t>, fun<nm::EW_GT, nm::Complex128, float32_t>, fun<nm::EW_GT, nm::Complex128, float64_t>, fun<nm::EW_GT, nm::Complex128, nm::Complex64>, fun<nm::EW_GT, nm::Complex128, nm::Complex128>, NULL}, \
{NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, fun<nm::EW_GT, nm::RubyObject, nm::RubyObject>}}, \
{{fun<nm::EW_LEQ, uint8_t, uint8_t>, fun<nm::EW_LEQ, uint8_t, int8_t>, fun<nm::EW_LEQ, uint8_t, int16_t>, fun<nm::EW_LEQ, uint8_t, int32_t>, fun<nm::EW_LEQ, uint8_t, int64_t>, fun<nm::EW_LEQ, uint8_t, float32_t>, fun<nm::EW_LEQ, uint8_t, float64_t>, fun<nm::EW_LEQ, uint8_t, nm::Complex64>, fun<nm::EW_LEQ, uint8_t, nm::Complex128>, NULL}, \
{fun<nm::EW_LEQ, int8_t, uint8_t>, fun<nm::EW_LEQ, int8_t, int8_t>, fun<nm::EW_LEQ, int8_t, int16_t>, fun<nm::EW_LEQ, int8_t, int32_t>, fun<nm::EW_LEQ, int8_t, int64_t>, fun<nm::EW_LEQ, int8_t, float32_t>, fun<nm::EW_LEQ, int8_t, float64_t>, fun<nm::EW_LEQ, int8_t, nm::Complex64>, fun<nm::EW_LEQ, int8_t, nm::Complex128>, NULL}, \
{fun<nm::EW_LEQ, int16_t, uint8_t>, fun<nm::EW_LEQ, int16_t, int8_t>, fun<nm::EW_LEQ, int16_t, int16_t>, fun<nm::EW_LEQ, int16_t, int32_t>, fun<nm::EW_LEQ, int16_t, int64_t>, fun<nm::EW_LEQ, int16_t, float32_t>, fun<nm::EW_LEQ, int16_t, float64_t>, fun<nm::EW_LEQ, int16_t, nm::Complex64>, fun<nm::EW_LEQ, int16_t, nm::Complex128>, NULL}, \
{fun<nm::EW_LEQ, int32_t, uint8_t>, fun<nm::EW_LEQ, int32_t, int8_t>, fun<nm::EW_LEQ, int32_t, int16_t>, fun<nm::EW_LEQ, int32_t, int32_t>, fun<nm::EW_LEQ, int32_t, int64_t>, fun<nm::EW_LEQ, int32_t, float32_t>, fun<nm::EW_LEQ, int32_t, float64_t>, fun<nm::EW_LEQ, int32_t, nm::Complex64>, fun<nm::EW_LEQ, int32_t, nm::Complex128>, NULL}, \
{fun<nm::EW_LEQ, int64_t, uint8_t>, fun<nm::EW_LEQ, int64_t, int8_t>, fun<nm::EW_LEQ, int64_t, int16_t>, fun<nm::EW_LEQ, int64_t, int32_t>, fun<nm::EW_LEQ, int64_t, int64_t>, fun<nm::EW_LEQ, int64_t, float32_t>, fun<nm::EW_LEQ, int64_t, float64_t>, fun<nm::EW_LEQ, int64_t, nm::Complex64>, fun<nm::EW_LEQ, int64_t, nm::Complex128>, NULL}, \
{fun<nm::EW_LEQ, float32_t, uint8_t>, fun<nm::EW_LEQ, float32_t, int8_t>, fun<nm::EW_LEQ, float32_t, int16_t>, fun<nm::EW_LEQ, float32_t, int32_t>, fun<nm::EW_LEQ, float32_t, int64_t>, fun<nm::EW_LEQ, float32_t, float32_t>, fun<nm::EW_LEQ, float32_t, float64_t>, fun<nm::EW_LEQ, float32_t, nm::Complex64>, fun<nm::EW_LEQ, float32_t, nm::Complex128>, NULL}, \
{fun<nm::EW_LEQ, float64_t, uint8_t>, fun<nm::EW_LEQ, float64_t, int8_t>, fun<nm::EW_LEQ, float64_t, int16_t>, fun<nm::EW_LEQ, float64_t, int32_t>, fun<nm::EW_LEQ, float64_t, int64_t>, fun<nm::EW_LEQ, float64_t, float32_t>, fun<nm::EW_LEQ, float64_t, float64_t>, fun<nm::EW_LEQ, float64_t, nm::Complex64>, fun<nm::EW_LEQ, float64_t, nm::Complex128>, NULL}, \
{fun<nm::EW_LEQ, nm::Complex64, uint8_t>, fun<nm::EW_LEQ, nm::Complex64, int8_t>, fun<nm::EW_LEQ, nm::Complex64, int16_t>, fun<nm::EW_LEQ, nm::Complex64, int32_t>, fun<nm::EW_LEQ, nm::Complex64, int64_t>, fun<nm::EW_LEQ, nm::Complex64, float32_t>, fun<nm::EW_LEQ, nm::Complex64, float64_t>, fun<nm::EW_LEQ, nm::Complex64, nm::Complex64>, fun<nm::EW_LEQ, nm::Complex64, nm::Complex128>, NULL}, \
{fun<nm::EW_LEQ, nm::Complex128, uint8_t>, fun<nm::EW_LEQ, nm::Complex128, int8_t>, fun<nm::EW_LEQ, nm::Complex128, int16_t>, fun<nm::EW_LEQ, nm::Complex128, int32_t>, fun<nm::EW_LEQ, nm::Complex128, int64_t>, fun<nm::EW_LEQ, nm::Complex128, float32_t>, fun<nm::EW_LEQ, nm::Complex128, float64_t>, fun<nm::EW_LEQ, nm::Complex128, nm::Complex64>, fun<nm::EW_LEQ, nm::Complex128, nm::Complex128>, NULL}, \
{NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, fun<nm::EW_LEQ, nm::RubyObject, nm::RubyObject>}}, \
{{fun<nm::EW_GEQ, uint8_t, uint8_t>, fun<nm::EW_GEQ, uint8_t, int8_t>, fun<nm::EW_GEQ, uint8_t, int16_t>, fun<nm::EW_GEQ, uint8_t, int32_t>, fun<nm::EW_GEQ, uint8_t, int64_t>, fun<nm::EW_GEQ, uint8_t, float32_t>, fun<nm::EW_GEQ, uint8_t, float64_t>, fun<nm::EW_GEQ, uint8_t, nm::Complex64>, fun<nm::EW_GEQ, uint8_t, nm::Complex128>, NULL}, \
{fun<nm::EW_GEQ, int8_t, uint8_t>, fun<nm::EW_GEQ, int8_t, int8_t>, fun<nm::EW_GEQ, int8_t, int16_t>, fun<nm::EW_GEQ, int8_t, int32_t>, fun<nm::EW_GEQ, int8_t, int64_t>, fun<nm::EW_GEQ, int8_t, float32_t>, fun<nm::EW_GEQ, int8_t, float64_t>, fun<nm::EW_GEQ, int8_t, nm::Complex64>, fun<nm::EW_GEQ, int8_t, nm::Complex128>, NULL}, \
{fun<nm::EW_GEQ, int16_t, uint8_t>, fun<nm::EW_GEQ, int16_t, int8_t>, fun<nm::EW_GEQ, int16_t, int16_t>, fun<nm::EW_GEQ, int16_t, int32_t>, fun<nm::EW_GEQ, int16_t, int64_t>, fun<nm::EW_GEQ, int16_t, float32_t>, fun<nm::EW_GEQ, int16_t, float64_t>, fun<nm::EW_GEQ, int16_t, nm::Complex64>, fun<nm::EW_GEQ, int16_t, nm::Complex128>, NULL}, \
{fun<nm::EW_GEQ, int32_t, uint8_t>, fun<nm::EW_GEQ, int32_t, int8_t>, fun<nm::EW_GEQ, int32_t, int16_t>, fun<nm::EW_GEQ, int32_t, int32_t>, fun<nm::EW_GEQ, int32_t, int64_t>, fun<nm::EW_GEQ, int32_t, float32_t>, fun<nm::EW_GEQ, int32_t, float64_t>, fun<nm::EW_GEQ, int32_t, nm::Complex64>, fun<nm::EW_GEQ, int32_t, nm::Complex128>, NULL}, \
{fun<nm::EW_GEQ, int64_t, uint8_t>, fun<nm::EW_GEQ, int64_t, int8_t>, fun<nm::EW_GEQ, int64_t, int16_t>, fun<nm::EW_GEQ, int64_t, int32_t>, fun<nm::EW_GEQ, int64_t, int64_t>, fun<nm::EW_GEQ, int64_t, float32_t>, fun<nm::EW_GEQ, int64_t, float64_t>, fun<nm::EW_GEQ, int64_t, nm::Complex64>, fun<nm::EW_GEQ, int64_t, nm::Complex128>, NULL}, \
{fun<nm::EW_GEQ, float32_t, uint8_t>, fun<nm::EW_GEQ, float32_t, int8_t>, fun<nm::EW_GEQ, float32_t, int16_t>, fun<nm::EW_GEQ, float32_t, int32_t>, fun<nm::EW_GEQ, float32_t, int64_t>, fun<nm::EW_GEQ, float32_t, float32_t>, fun<nm::EW_GEQ, float32_t, float64_t>, fun<nm::EW_GEQ, float32_t, nm::Complex64>, fun<nm::EW_GEQ, float32_t, nm::Complex128>, NULL}, \
{fun<nm::EW_GEQ, float64_t, uint8_t>, fun<nm::EW_GEQ, float64_t, int8_t>, fun<nm::EW_GEQ, float64_t, int16_t>, fun<nm::EW_GEQ, float64_t, int32_t>, fun<nm::EW_GEQ, float64_t, int64_t>, fun<nm::EW_GEQ, float64_t, float32_t>, fun<nm::EW_GEQ, float64_t, float64_t>, fun<nm::EW_GEQ, float64_t, nm::Complex64>, fun<nm::EW_GEQ, float64_t, nm::Complex128>, NULL}, \
{fun<nm::EW_GEQ, nm::Complex64, uint8_t>, fun<nm::EW_GEQ, nm::Complex64, int8_t>, fun<nm::EW_GEQ, nm::Complex64, int16_t>, fun<nm::EW_GEQ, nm::Complex64, int32_t>, fun<nm::EW_GEQ, nm::Complex64, int64_t>, fun<nm::EW_GEQ, nm::Complex64, float32_t>, fun<nm::EW_GEQ, nm::Complex64, float64_t>, fun<nm::EW_GEQ, nm::Complex64, nm::Complex64>, fun<nm::EW_GEQ, nm::Complex64, nm::Complex128>, NULL}, \
{fun<nm::EW_GEQ, nm::Complex128, uint8_t>, fun<nm::EW_GEQ, nm::Complex128, int8_t>, fun<nm::EW_GEQ, nm::Complex128, int16_t>, fun<nm::EW_GEQ, nm::Complex128, int32_t>, fun<nm::EW_GEQ, nm::Complex128, int64_t>, fun<nm::EW_GEQ, nm::Complex128, float32_t>, fun<nm::EW_GEQ, nm::Complex128, float64_t>, fun<nm::EW_GEQ, nm::Complex128, nm::Complex64>, fun<nm::EW_GEQ, nm::Complex128, nm::Complex128>, NULL}, \
{NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, fun<nm::EW_GEQ, nm::RubyObject, nm::RubyObject>} \
} \
};
/*
* Defines a static array that holds function pointers to an elementwise op,
* itype, dtype templated versions of the specified function.
*/
#define OP_ITYPE_DTYPE_TEMPLATE_TABLE(fun, ret, ...) NAMED_OP_ITYPE_DTYPE_TEMPLATE_TABLE(ttable, fun, ret, __VA_ARGS__)
#define NAMED_OP_ITYPE_DTYPE_TEMPLATE_TABLE(name, fun, ret, ...) \
static ret (*(name)[nm::NUM_EWOPS][nm::NUM_ITYPES][nm::NUM_DTYPES])(__VA_ARGS__) = \
{{{fun<nm::EW_ADD, uint8_t, uint8_t>,fun<nm::EW_ADD, uint8_t, int8_t>,fun<nm::EW_ADD, uint8_t, int16_t>,fun<nm::EW_ADD, uint8_t, int32_t>,fun<nm::EW_ADD, uint8_t, int64_t>,fun<nm::EW_ADD, uint8_t, float32_t>,fun<nm::EW_ADD, uint8_t, float64_t>,fun<nm::EW_ADD, uint8_t, nm::Complex64>,fun<nm::EW_ADD, uint8_t, nm::Complex128>,fun<nm::EW_ADD, uint8_t, nm::RubyObject>},\
{fun<nm::EW_ADD, uint16_t, uint8_t>,fun<nm::EW_ADD, uint16_t, int8_t>,fun<nm::EW_ADD, uint16_t, int16_t>,fun<nm::EW_ADD, uint16_t, int32_t>,fun<nm::EW_ADD, uint16_t, int64_t>,fun<nm::EW_ADD, uint16_t, float32_t>,fun<nm::EW_ADD, uint16_t, float64_t>,fun<nm::EW_ADD, uint16_t, nm::Complex64>,fun<nm::EW_ADD, uint16_t, nm::Complex128>,fun<nm::EW_ADD, uint16_t, nm::RubyObject>},\
{fun<nm::EW_ADD, uint32_t, uint8_t>,fun<nm::EW_ADD, uint32_t, int8_t>,fun<nm::EW_ADD, uint32_t, int16_t>,fun<nm::EW_ADD, uint32_t, int32_t>,fun<nm::EW_ADD, uint32_t, int64_t>,fun<nm::EW_ADD, uint32_t, float32_t>,fun<nm::EW_ADD, uint32_t, float64_t>,fun<nm::EW_ADD, uint32_t, nm::Complex64>,fun<nm::EW_ADD, uint32_t, nm::Complex128>,fun<nm::EW_ADD, uint32_t, nm::RubyObject>},\
{fun<nm::EW_ADD, uint64_t, uint8_t>,fun<nm::EW_ADD, uint64_t, int8_t>,fun<nm::EW_ADD, uint64_t, int16_t>,fun<nm::EW_ADD, uint64_t, int32_t>,fun<nm::EW_ADD, uint64_t, int64_t>,fun<nm::EW_ADD, uint64_t, float32_t>,fun<nm::EW_ADD, uint64_t, float64_t>,fun<nm::EW_ADD, uint64_t, nm::Complex64>,fun<nm::EW_ADD, uint64_t, nm::Complex128>,fun<nm::EW_ADD, uint64_t, nm::RubyObject>}},\
{{fun<nm::EW_SUB, uint8_t, uint8_t>,fun<nm::EW_SUB, uint8_t, int8_t>,fun<nm::EW_SUB, uint8_t, int16_t>,fun<nm::EW_SUB, uint8_t, int32_t>,fun<nm::EW_SUB, uint8_t, int64_t>,fun<nm::EW_SUB, uint8_t, float32_t>,fun<nm::EW_SUB, uint8_t, float64_t>,fun<nm::EW_SUB, uint8_t, nm::Complex64>,fun<nm::EW_SUB, uint8_t, nm::Complex128>,fun<nm::EW_SUB, uint8_t, nm::RubyObject>},\
{fun<nm::EW_SUB, uint16_t, uint8_t>,fun<nm::EW_SUB, uint16_t, int8_t>,fun<nm::EW_SUB, uint16_t, int16_t>,fun<nm::EW_SUB, uint16_t, int32_t>,fun<nm::EW_SUB, uint16_t, int64_t>,fun<nm::EW_SUB, uint16_t, float32_t>,fun<nm::EW_SUB, uint16_t, float64_t>,fun<nm::EW_SUB, uint16_t, nm::Complex64>,fun<nm::EW_SUB, uint16_t, nm::Complex128>,fun<nm::EW_SUB, uint16_t, nm::RubyObject>},\
{fun<nm::EW_SUB, uint32_t, uint8_t>,fun<nm::EW_SUB, uint32_t, int8_t>,fun<nm::EW_SUB, uint32_t, int16_t>,fun<nm::EW_SUB, uint32_t, int32_t>,fun<nm::EW_SUB, uint32_t, int64_t>,fun<nm::EW_SUB, uint32_t, float32_t>,fun<nm::EW_SUB, uint32_t, float64_t>,fun<nm::EW_SUB, uint32_t, nm::Complex64>,fun<nm::EW_SUB, uint32_t, nm::Complex128>,fun<nm::EW_SUB, uint32_t, nm::RubyObject>},\
{fun<nm::EW_SUB, uint64_t, uint8_t>,fun<nm::EW_SUB, uint64_t, int8_t>,fun<nm::EW_SUB, uint64_t, int16_t>,fun<nm::EW_SUB, uint64_t, int32_t>,fun<nm::EW_SUB, uint64_t, int64_t>,fun<nm::EW_SUB, uint64_t, float32_t>,fun<nm::EW_SUB, uint64_t, float64_t>,fun<nm::EW_SUB, uint64_t, nm::Complex64>,fun<nm::EW_SUB, uint64_t, nm::Complex128>,fun<nm::EW_SUB, uint64_t, nm::RubyObject>}},\
{{fun<nm::EW_MUL, uint8_t, uint8_t>,fun<nm::EW_MUL, uint8_t, int8_t>,fun<nm::EW_MUL, uint8_t, int16_t>,fun<nm::EW_MUL, uint8_t, int32_t>,fun<nm::EW_MUL, uint8_t, int64_t>,fun<nm::EW_MUL, uint8_t, float32_t>,fun<nm::EW_MUL, uint8_t, float64_t>,fun<nm::EW_MUL, uint8_t, nm::Complex64>,fun<nm::EW_MUL, uint8_t, nm::Complex128>,fun<nm::EW_MUL, uint8_t, nm::RubyObject>},\
{fun<nm::EW_MUL, uint16_t, uint8_t>,fun<nm::EW_MUL, uint16_t, int8_t>,fun<nm::EW_MUL, uint16_t, int16_t>,fun<nm::EW_MUL, uint16_t, int32_t>,fun<nm::EW_MUL, uint16_t, int64_t>,fun<nm::EW_MUL, uint16_t, float32_t>,fun<nm::EW_MUL, uint16_t, float64_t>,fun<nm::EW_MUL, uint16_t, nm::Complex64>,fun<nm::EW_MUL, uint16_t, nm::Complex128>,fun<nm::EW_MUL, uint16_t, nm::RubyObject>},\
{fun<nm::EW_MUL, uint32_t, uint8_t>,fun<nm::EW_MUL, uint32_t, int8_t>,fun<nm::EW_MUL, uint32_t, int16_t>,fun<nm::EW_MUL, uint32_t, int32_t>,fun<nm::EW_MUL, uint32_t, int64_t>,fun<nm::EW_MUL, uint32_t, float32_t>,fun<nm::EW_MUL, uint32_t, float64_t>,fun<nm::EW_MUL, uint32_t, nm::Complex64>,fun<nm::EW_MUL, uint32_t, nm::Complex128>,fun<nm::EW_MUL, uint32_t, nm::RubyObject>},\
{fun<nm::EW_MUL, uint64_t, uint8_t>,fun<nm::EW_MUL, uint64_t, int8_t>,fun<nm::EW_MUL, uint64_t, int16_t>,fun<nm::EW_MUL, uint64_t, int32_t>,fun<nm::EW_MUL, uint64_t, int64_t>,fun<nm::EW_MUL, uint64_t, float32_t>,fun<nm::EW_MUL, uint64_t, float64_t>,fun<nm::EW_MUL, uint64_t, nm::Complex64>,fun<nm::EW_MUL, uint64_t, nm::Complex128>,fun<nm::EW_MUL, uint64_t, nm::RubyObject>}},\
{{fun<nm::EW_DIV, uint8_t, uint8_t>,fun<nm::EW_DIV, uint8_t, int8_t>,fun<nm::EW_DIV, uint8_t, int16_t>,fun<nm::EW_DIV, uint8_t, int32_t>,fun<nm::EW_DIV, uint8_t, int64_t>,fun<nm::EW_DIV, uint8_t, float32_t>,fun<nm::EW_DIV, uint8_t, float64_t>,fun<nm::EW_DIV, uint8_t, nm::Complex64>,fun<nm::EW_DIV, uint8_t, nm::Complex128>,fun<nm::EW_DIV, uint8_t, nm::RubyObject>},\
{fun<nm::EW_DIV, uint16_t, uint8_t>,fun<nm::EW_DIV, uint16_t, int8_t>,fun<nm::EW_DIV, uint16_t, int16_t>,fun<nm::EW_DIV, uint16_t, int32_t>,fun<nm::EW_DIV, uint16_t, int64_t>,fun<nm::EW_DIV, uint16_t, float32_t>,fun<nm::EW_DIV, uint16_t, float64_t>,fun<nm::EW_DIV, uint16_t, nm::Complex64>,fun<nm::EW_DIV, uint16_t, nm::Complex128>,fun<nm::EW_DIV, uint16_t, nm::RubyObject>},\
{fun<nm::EW_DIV, uint32_t, uint8_t>,fun<nm::EW_DIV, uint32_t, int8_t>,fun<nm::EW_DIV, uint32_t, int16_t>,fun<nm::EW_DIV, uint32_t, int32_t>,fun<nm::EW_DIV, uint32_t, int64_t>,fun<nm::EW_DIV, uint32_t, float32_t>,fun<nm::EW_DIV, uint32_t, float64_t>,fun<nm::EW_DIV, uint32_t, nm::Complex64>,fun<nm::EW_DIV, uint32_t, nm::Complex128>,fun<nm::EW_DIV, uint32_t, nm::RubyObject>},\
{fun<nm::EW_DIV, uint64_t, uint8_t>,fun<nm::EW_DIV, uint64_t, int8_t>,fun<nm::EW_DIV, uint64_t, int16_t>,fun<nm::EW_DIV, uint64_t, int32_t>,fun<nm::EW_DIV, uint64_t, int64_t>,fun<nm::EW_DIV, uint64_t, float32_t>,fun<nm::EW_DIV, uint64_t, float64_t>,fun<nm::EW_DIV, uint64_t, nm::Complex64>,fun<nm::EW_DIV, uint64_t, nm::Complex128>,fun<nm::EW_DIV, uint64_t, nm::RubyObject>}},\
{{fun<nm::EW_MOD, uint8_t, uint8_t>,fun<nm::EW_MOD, uint8_t, int8_t>,fun<nm::EW_MOD, uint8_t, int16_t>,fun<nm::EW_MOD, uint8_t, int32_t>,fun<nm::EW_MOD, uint8_t, int64_t>,fun<nm::EW_MOD, uint8_t, float32_t>,fun<nm::EW_MOD, uint8_t, float64_t>,fun<nm::EW_MOD, uint8_t, nm::Complex64>,fun<nm::EW_MOD, uint8_t, nm::Complex128>,fun<nm::EW_MOD, uint8_t, nm::RubyObject>},\
{fun<nm::EW_MOD, uint16_t, uint8_t>,fun<nm::EW_MOD, uint16_t, int8_t>,fun<nm::EW_MOD, uint16_t, int16_t>,fun<nm::EW_MOD, uint16_t, int32_t>,fun<nm::EW_MOD, uint16_t, int64_t>,fun<nm::EW_MOD, uint16_t, float32_t>,fun<nm::EW_MOD, uint16_t, float64_t>,fun<nm::EW_MOD, uint16_t, nm::Complex64>,fun<nm::EW_MOD, uint16_t, nm::Complex128>,fun<nm::EW_MOD, uint16_t, nm::RubyObject>},\
{fun<nm::EW_MOD, uint32_t, uint8_t>,fun<nm::EW_MOD, uint32_t, int8_t>,fun<nm::EW_MOD, uint32_t, int16_t>,fun<nm::EW_MOD, uint32_t, int32_t>,fun<nm::EW_MOD, uint32_t, int64_t>,fun<nm::EW_MOD, uint32_t, float32_t>,fun<nm::EW_MOD, uint32_t, float64_t>,fun<nm::EW_MOD, uint32_t, nm::Complex64>,fun<nm::EW_MOD, uint32_t, nm::Complex128>,fun<nm::EW_MOD, uint32_t, nm::RubyObject>},\
{fun<nm::EW_MOD, uint64_t, uint8_t>,fun<nm::EW_MOD, uint64_t, int8_t>,fun<nm::EW_MOD, uint64_t, int16_t>,fun<nm::EW_MOD, uint64_t, int32_t>,fun<nm::EW_MOD, uint64_t, int64_t>,fun<nm::EW_MOD, uint64_t, float32_t>,fun<nm::EW_MOD, uint64_t, float64_t>,fun<nm::EW_MOD, uint64_t, nm::Complex64>,fun<nm::EW_MOD, uint64_t, nm::Complex128>,fun<nm::EW_MOD, uint64_t, nm::RubyObject>}},\
{{fun<nm::EW_EQEQ, uint8_t, uint8_t>,fun<nm::EW_EQEQ, uint8_t, int8_t>,fun<nm::EW_EQEQ, uint8_t, int16_t>,fun<nm::EW_EQEQ, uint8_t, int32_t>,fun<nm::EW_EQEQ, uint8_t, int64_t>,fun<nm::EW_EQEQ, uint8_t, float32_t>,fun<nm::EW_EQEQ, uint8_t, float64_t>,fun<nm::EW_EQEQ, uint8_t, nm::Complex64>,fun<nm::EW_EQEQ, uint8_t, nm::Complex128>,fun<nm::EW_EQEQ, uint8_t, nm::RubyObject>},\
{fun<nm::EW_EQEQ, uint16_t, uint8_t>,fun<nm::EW_EQEQ, uint16_t, int8_t>,fun<nm::EW_EQEQ, uint16_t, int16_t>,fun<nm::EW_EQEQ, uint16_t, int32_t>,fun<nm::EW_EQEQ, uint16_t, int64_t>,fun<nm::EW_EQEQ, uint16_t, float32_t>,fun<nm::EW_EQEQ, uint16_t, float64_t>,fun<nm::EW_EQEQ, uint16_t, nm::Complex64>,fun<nm::EW_EQEQ, uint16_t, nm::Complex128>,fun<nm::EW_EQEQ, uint16_t, nm::RubyObject>},\
{fun<nm::EW_EQEQ, uint32_t, uint8_t>,fun<nm::EW_EQEQ, uint32_t, int8_t>,fun<nm::EW_EQEQ, uint32_t, int16_t>,fun<nm::EW_EQEQ, uint32_t, int32_t>,fun<nm::EW_EQEQ, uint32_t, int64_t>,fun<nm::EW_EQEQ, uint32_t, float32_t>,fun<nm::EW_EQEQ, uint32_t, float64_t>,fun<nm::EW_EQEQ, uint32_t, nm::Complex64>,fun<nm::EW_EQEQ, uint32_t, nm::Complex128>,fun<nm::EW_EQEQ, uint32_t, nm::RubyObject>},\
{fun<nm::EW_EQEQ, uint64_t, uint8_t>,fun<nm::EW_EQEQ, uint64_t, int8_t>,fun<nm::EW_EQEQ, uint64_t, int16_t>,fun<nm::EW_EQEQ, uint64_t, int32_t>,fun<nm::EW_EQEQ, uint64_t, int64_t>,fun<nm::EW_EQEQ, uint64_t, float32_t>,fun<nm::EW_EQEQ, uint64_t, float64_t>,fun<nm::EW_EQEQ, uint64_t, nm::Complex64>,fun<nm::EW_EQEQ, uint64_t, nm::Complex128>,fun<nm::EW_EQEQ, uint64_t, nm::RubyObject>}},\
{{fun<nm::EW_NEQ, uint8_t, uint8_t>,fun<nm::EW_NEQ, uint8_t, int8_t>,fun<nm::EW_NEQ, uint8_t, int16_t>,fun<nm::EW_NEQ, uint8_t, int32_t>,fun<nm::EW_NEQ, uint8_t, int64_t>,fun<nm::EW_NEQ, uint8_t, float32_t>,fun<nm::EW_NEQ, uint8_t, float64_t>,fun<nm::EW_NEQ, uint8_t, nm::Complex64>,fun<nm::EW_NEQ, uint8_t, nm::Complex128>,fun<nm::EW_NEQ, uint8_t, nm::RubyObject>},\
{fun<nm::EW_NEQ, uint16_t, uint8_t>,fun<nm::EW_NEQ, uint16_t, int8_t>,fun<nm::EW_NEQ, uint16_t, int16_t>,fun<nm::EW_NEQ, uint16_t, int32_t>,fun<nm::EW_NEQ, uint16_t, int64_t>,fun<nm::EW_NEQ, uint16_t, float32_t>,fun<nm::EW_NEQ, uint16_t, float64_t>,fun<nm::EW_NEQ, uint16_t, nm::Complex64>,fun<nm::EW_NEQ, uint16_t, nm::Complex128>,fun<nm::EW_NEQ, uint16_t, nm::RubyObject>},\
{fun<nm::EW_NEQ, uint32_t, uint8_t>,fun<nm::EW_NEQ, uint32_t, int8_t>,fun<nm::EW_NEQ, uint32_t, int16_t>,fun<nm::EW_NEQ, uint32_t, int32_t>,fun<nm::EW_NEQ, uint32_t, int64_t>,fun<nm::EW_NEQ, uint32_t, float32_t>,fun<nm::EW_NEQ, uint32_t, float64_t>,fun<nm::EW_NEQ, uint32_t, nm::Complex64>,fun<nm::EW_NEQ, uint32_t, nm::Complex128>,fun<nm::EW_NEQ, uint32_t, nm::RubyObject>},\
{fun<nm::EW_NEQ, uint64_t, uint8_t>,fun<nm::EW_NEQ, uint64_t, int8_t>,fun<nm::EW_NEQ, uint64_t, int16_t>,fun<nm::EW_NEQ, uint64_t, int32_t>,fun<nm::EW_NEQ, uint64_t, int64_t>,fun<nm::EW_NEQ, uint64_t, float32_t>,fun<nm::EW_NEQ, uint64_t, float64_t>,fun<nm::EW_NEQ, uint64_t, nm::Complex64>,fun<nm::EW_NEQ, uint64_t, nm::Complex128>,fun<nm::EW_NEQ, uint64_t, nm::RubyObject>}},\
{{fun<nm::EW_LT, uint8_t, uint8_t>,fun<nm::EW_LT, uint8_t, int8_t>,fun<nm::EW_LT, uint8_t, int16_t>,fun<nm::EW_LT, uint8_t, int32_t>,fun<nm::EW_LT, uint8_t, int64_t>,fun<nm::EW_LT, uint8_t, float32_t>,fun<nm::EW_LT, uint8_t, float64_t>,fun<nm::EW_LT, uint8_t, nm::Complex64>,fun<nm::EW_LT, uint8_t, nm::Complex128>,fun<nm::EW_LT, uint8_t, nm::RubyObject>},\
{fun<nm::EW_LT, uint16_t, uint8_t>,fun<nm::EW_LT, uint16_t, int8_t>,fun<nm::EW_LT, uint16_t, int16_t>,fun<nm::EW_LT, uint16_t, int32_t>,fun<nm::EW_LT, uint16_t, int64_t>,fun<nm::EW_LT, uint16_t, float32_t>,fun<nm::EW_LT, uint16_t, float64_t>,fun<nm::EW_LT, uint16_t, nm::Complex64>,fun<nm::EW_LT, uint16_t, nm::Complex128>,fun<nm::EW_LT, uint16_t, nm::RubyObject>},\
{fun<nm::EW_LT, uint32_t, uint8_t>,fun<nm::EW_LT, uint32_t, int8_t>,fun<nm::EW_LT, uint32_t, int16_t>,fun<nm::EW_LT, uint32_t, int32_t>,fun<nm::EW_LT, uint32_t, int64_t>,fun<nm::EW_LT, uint32_t, float32_t>,fun<nm::EW_LT, uint32_t, float64_t>,fun<nm::EW_LT, uint32_t, nm::Complex64>,fun<nm::EW_LT, uint32_t, nm::Complex128>,fun<nm::EW_LT, uint32_t, nm::RubyObject>},\
{fun<nm::EW_LT, uint64_t, uint8_t>,fun<nm::EW_LT, uint64_t, int8_t>,fun<nm::EW_LT, uint64_t, int16_t>,fun<nm::EW_LT, uint64_t, int32_t>,fun<nm::EW_LT, uint64_t, int64_t>,fun<nm::EW_LT, uint64_t, float32_t>,fun<nm::EW_LT, uint64_t, float64_t>,fun<nm::EW_LT, uint64_t, nm::Complex64>,fun<nm::EW_LT, uint64_t, nm::Complex128>,fun<nm::EW_LT, uint64_t, nm::RubyObject>}},\
{{fun<nm::EW_GT, uint8_t, uint8_t>,fun<nm::EW_GT, uint8_t, int8_t>,fun<nm::EW_GT, uint8_t, int16_t>,fun<nm::EW_GT, uint8_t, int32_t>,fun<nm::EW_GT, uint8_t, int64_t>,fun<nm::EW_GT, uint8_t, float32_t>,fun<nm::EW_GT, uint8_t, float64_t>,fun<nm::EW_GT, uint8_t, nm::Complex64>,fun<nm::EW_GT, uint8_t, nm::Complex128>,fun<nm::EW_GT, uint8_t, nm::RubyObject>},\
{fun<nm::EW_GT, uint16_t, uint8_t>,fun<nm::EW_GT, uint16_t, int8_t>,fun<nm::EW_GT, uint16_t, int16_t>,fun<nm::EW_GT, uint16_t, int32_t>,fun<nm::EW_GT, uint16_t, int64_t>,fun<nm::EW_GT, uint16_t, float32_t>,fun<nm::EW_GT, uint16_t, float64_t>,fun<nm::EW_GT, uint16_t, nm::Complex64>,fun<nm::EW_GT, uint16_t, nm::Complex128>,fun<nm::EW_GT, uint16_t, nm::RubyObject>},\
{fun<nm::EW_GT, uint32_t, uint8_t>,fun<nm::EW_GT, uint32_t, int8_t>,fun<nm::EW_GT, uint32_t, int16_t>,fun<nm::EW_GT, uint32_t, int32_t>,fun<nm::EW_GT, uint32_t, int64_t>,fun<nm::EW_GT, uint32_t, float32_t>,fun<nm::EW_GT, uint32_t, float64_t>,fun<nm::EW_GT, uint32_t, nm::Complex64>,fun<nm::EW_GT, uint32_t, nm::Complex128>,fun<nm::EW_GT, uint32_t, nm::RubyObject>},\
{fun<nm::EW_GT, uint64_t, uint8_t>,fun<nm::EW_GT, uint64_t, int8_t>,fun<nm::EW_GT, uint64_t, int16_t>,fun<nm::EW_GT, uint64_t, int32_t>,fun<nm::EW_GT, uint64_t, int64_t>,fun<nm::EW_GT, uint64_t, float32_t>,fun<nm::EW_GT, uint64_t, float64_t>,fun<nm::EW_GT, uint64_t, nm::Complex64>,fun<nm::EW_GT, uint64_t, nm::Complex128>,fun<nm::EW_GT, uint64_t, nm::RubyObject>}},\
{{fun<nm::EW_LEQ, uint8_t, uint8_t>,fun<nm::EW_LEQ, uint8_t, int8_t>,fun<nm::EW_LEQ, uint8_t, int16_t>,fun<nm::EW_LEQ, uint8_t, int32_t>,fun<nm::EW_LEQ, uint8_t, int64_t>,fun<nm::EW_LEQ, uint8_t, float32_t>,fun<nm::EW_LEQ, uint8_t, float64_t>,fun<nm::EW_LEQ, uint8_t, nm::Complex64>,fun<nm::EW_LEQ, uint8_t, nm::Complex128>,fun<nm::EW_LEQ, uint8_t, nm::RubyObject>},\
{fun<nm::EW_LEQ, uint16_t, uint8_t>,fun<nm::EW_LEQ, uint16_t, int8_t>,fun<nm::EW_LEQ, uint16_t, int16_t>,fun<nm::EW_LEQ, uint16_t, int32_t>,fun<nm::EW_LEQ, uint16_t, int64_t>,fun<nm::EW_LEQ, uint16_t, float32_t>,fun<nm::EW_LEQ, uint16_t, float64_t>,fun<nm::EW_LEQ, uint16_t, nm::Complex64>,fun<nm::EW_LEQ, uint16_t, nm::Complex128>,fun<nm::EW_LEQ, uint16_t, nm::RubyObject>},\
{fun<nm::EW_LEQ, uint32_t, uint8_t>,fun<nm::EW_LEQ, uint32_t, int8_t>,fun<nm::EW_LEQ, uint32_t, int16_t>,fun<nm::EW_LEQ, uint32_t, int32_t>,fun<nm::EW_LEQ, uint32_t, int64_t>,fun<nm::EW_LEQ, uint32_t, float32_t>,fun<nm::EW_LEQ, uint32_t, float64_t>,fun<nm::EW_LEQ, uint32_t, nm::Complex64>,fun<nm::EW_LEQ, uint32_t, nm::Complex128>,fun<nm::EW_LEQ, uint32_t, nm::RubyObject>},\
{fun<nm::EW_LEQ, uint64_t, uint8_t>,fun<nm::EW_LEQ, uint64_t, int8_t>,fun<nm::EW_LEQ, uint64_t, int16_t>,fun<nm::EW_LEQ, uint64_t, int32_t>,fun<nm::EW_LEQ, uint64_t, int64_t>,fun<nm::EW_LEQ, uint64_t, float32_t>,fun<nm::EW_LEQ, uint64_t, float64_t>,fun<nm::EW_LEQ, uint64_t, nm::Complex64>,fun<nm::EW_LEQ, uint64_t, nm::Complex128>,fun<nm::EW_LEQ, uint64_t, nm::RubyObject>}},\
{{fun<nm::EW_GEQ, uint8_t, uint8_t>,fun<nm::EW_GEQ, uint8_t, int8_t>,fun<nm::EW_GEQ, uint8_t, int16_t>,fun<nm::EW_GEQ, uint8_t, int32_t>,fun<nm::EW_GEQ, uint8_t, int64_t>,fun<nm::EW_GEQ, uint8_t, float32_t>,fun<nm::EW_GEQ, uint8_t, float64_t>,fun<nm::EW_GEQ, uint8_t, nm::Complex64>,fun<nm::EW_GEQ, uint8_t, nm::Complex128>,fun<nm::EW_GEQ, uint8_t, nm::RubyObject>},\
{fun<nm::EW_GEQ, uint16_t, uint8_t>,fun<nm::EW_GEQ, uint16_t, int8_t>,fun<nm::EW_GEQ, uint16_t, int16_t>,fun<nm::EW_GEQ, uint16_t, int32_t>,fun<nm::EW_GEQ, uint16_t, int64_t>,fun<nm::EW_GEQ, uint16_t, float32_t>,fun<nm::EW_GEQ, uint16_t, float64_t>,fun<nm::EW_GEQ, uint16_t, nm::Complex64>,fun<nm::EW_GEQ, uint16_t, nm::Complex128>,fun<nm::EW_GEQ, uint16_t, nm::RubyObject>},\
{fun<nm::EW_GEQ, uint32_t, uint8_t>,fun<nm::EW_GEQ, uint32_t, int8_t>,fun<nm::EW_GEQ, uint32_t, int16_t>,fun<nm::EW_GEQ, uint32_t, int32_t>,fun<nm::EW_GEQ, uint32_t, int64_t>,fun<nm::EW_GEQ, uint32_t, float32_t>,fun<nm::EW_GEQ, uint32_t, float64_t>,fun<nm::EW_GEQ, uint32_t, nm::Complex64>,fun<nm::EW_GEQ, uint32_t, nm::Complex128>,fun<nm::EW_GEQ, uint32_t, nm::RubyObject>},\
{fun<nm::EW_GEQ, uint64_t, uint8_t>,fun<nm::EW_GEQ, uint64_t, int8_t>,fun<nm::EW_GEQ, uint64_t, int16_t>,fun<nm::EW_GEQ, uint64_t, int32_t>,fun<nm::EW_GEQ, uint64_t, int64_t>,fun<nm::EW_GEQ, uint64_t, float32_t>,fun<nm::EW_GEQ, uint64_t, float64_t>,fun<nm::EW_GEQ, uint64_t, nm::Complex64>,fun<nm::EW_GEQ, uint64_t, nm::Complex128>,fun<nm::EW_GEQ, uint64_t, nm::RubyObject>}}};
extern "C" {
/*
* Data
*/
// regular data types
extern const char* const DTYPE_NAMES[nm::NUM_DTYPES];
extern const size_t DTYPE_SIZES[nm::NUM_DTYPES];
extern const nm::dtype_t Upcast[nm::NUM_DTYPES][nm::NUM_DTYPES];
/*
* Functions
*/
void* rubyobj_to_cval(VALUE val, nm::dtype_t dtype);
void rubyval_to_cval(VALUE val, nm::dtype_t dtype, void* loc);
void nm_init_data();
} // end of extern "C" block
#endif // DATA_H
================================================
FILE: ext/nmatrix/data/meta.h
================================================
/////////////////////////////////////////////////////////////////////
// = NMatrix
//
// A linear algebra library for scientific computation in Ruby.
// NMatrix is part of SciRuby.
//
// NMatrix was originally inspired by and derived from NArray, by
// Masahiro Tanaka: http://narray.rubyforge.org
//
// == Copyright Information
//
// SciRuby is Copyright (c) 2010 - 2014, Ruby Science Foundation
// NMatrix is Copyright (c) 2012 - 2014, John Woods and the Ruby Science Foundation
//
// Please see LICENSE.txt for additional copyright notices.
//
// == Contributing
//
// By contributing source code to SciRuby, you agree to be bound by
// our Contributor Agreement:
//
// * https://github.com/SciRuby/sciruby/wiki/Contributor-Agreement
//
// == meta.h
//
// Header file for dealing with template metaprogramming.
#ifndef META_H
# define META_H
namespace nm {
/*
* Template Metaprogramming
*/
template <typename T> struct ctype_to_dtype_enum {
static const nm::dtype_t value_type = nm::BYTE;
};
template <> struct ctype_to_dtype_enum<uint8_t> { static const nm::dtype_t value_type = nm::BYTE; };
template <> struct ctype_to_dtype_enum<int8_t> { static const nm::dtype_t value_type = nm::INT8; };
template <> struct ctype_to_dtype_enum<int16_t> { static const nm::dtype_t value_type = nm::INT16; };
template <> struct ctype_to_dtype_enum<int32_t> { static const nm::dtype_t value_type = nm::INT32; };
template <> struct ctype_to_dtype_enum<int64_t> { static const nm::dtype_t value_type = nm::INT64; };
template <> struct ctype_to_dtype_enum<float> { static const nm::dtype_t value_type = nm::FLOAT32; };
template <> struct ctype_to_dtype_enum<double> { static const nm::dtype_t value_type = nm::FLOAT64; };
template <> struct ctype_to_dtype_enum<Complex64> { static const nm::dtype_t value_type = nm::COMPLEX64; };
template <> struct ctype_to_dtype_enum<Complex128> { static const nm::dtype_t value_type = nm::COMPLEX128; };
template <> struct ctype_to_dtype_enum<RubyObject> { static const nm::dtype_t value_type = nm::RUBYOBJ; };
template <nm::dtype_t Enum> struct dtype_enum_T;
template <> struct dtype_enum_T<nm::BYTE> { typedef uint8_t type; };
template <> struct dtype_enum_T<nm::INT8> { typedef int8_t type; };
template <> struct dtype_enum_T<nm::INT16> { typedef int16_t type; };
template <> struct dtype_enum_T<nm::INT32> { typedef int32_t type; };
template <> struct dtype_enum_T<nm::INT64> { typedef int64_t type; };
template <> struct dtype_enum_T<nm::FLOAT32> { typedef float type; };
template <> struct dtype_enum_T<nm::FLOAT64> { typedef double type; };
template <> struct dtype_enum_T<nm::COMPLEX64> { typedef nm::Complex64 type; };
template <> struct dtype_enum_T<nm::COMPLEX128> { typedef nm::Complex128 type; };
template <> struct dtype_enum_T<nm::RUBYOBJ> { typedef nm::RubyObject type; };
} // end namespace nm
#endif
================================================
FILE: ext/nmatrix/data/ruby_object.h
================================================
/////////////////////////////////////////////////////////////////////
// = NMatrix
//
// A linear algebra library for scientific computation in Ruby.
// NMatrix is part of SciRuby.
//
// NMatrix was originally inspired by and derived from NArray, by
// Masahiro Tanaka: http://narray.rubyforge.org
//
// == Copyright Information
//
// SciRuby is Copyright (c) 2010 - 2014, Ruby Science Foundation
// NMatrix is Copyright (c) 2012 - 2014, John Woods and the Ruby Science Foundation
//
// Please see LICENSE.txt for additional copyright notices.
//
// == Contributing
//
// By contributing source code to SciRuby, you agree to be bound by
// our Contributor Agreement:
//
// * https://github.com/SciRuby/sciruby/wiki/Contributor-Agreement
//
// == ruby_object.h
//
// Functions and classes for dealing with Ruby objects.
#ifndef RUBY_OBJECT_H
#define RUBY_OBJECT_H
/*
* Standard Includes
*/
#include <ruby.h>
#include <iostream>
#include <type_traits>
/*
* Project Includes
*/
#include "ruby_constants.h"
/*
* Macros
*/
#define NM_RUBYVAL_IS_NUMERIC(val) (FIXNUM_P(val) or RB_FLOAT_TYPE_P(val) or RB_TYPE_P(val, T_COMPLEX))
/*
* Classes and Functions
*/
namespace nm {
template<typename T, typename U>
struct made_from_same_template : std::false_type {};
template<template<typename> class Templ, typename Arg1, typename Arg2>
struct made_from_same_template<Templ<Arg1>, Templ<Arg2> > : std::true_type {};
class RubyObject {
public:
VALUE rval;
/*
* Value constructor.
*/
inline RubyObject(VALUE ref = Qnil) : rval(ref) {}
/*
* Complex number constructor.
*/
template <typename FloatType, typename = typename std::enable_if<std::is_floating_point<FloatType>::value>::type>
inline RubyObject(const Complex<FloatType>& other) : rval(rb_complex_new(rb_float_new(other.r), rb_float_new(other.i))) {}
/*
* Integer constructor.
*
* Does not work as a template.
*/
inline RubyObject(uint8_t other) : rval(INT2FIX(other)) {}
inline RubyObject(int8_t other) : rval(INT2FIX(other)) {}
inline RubyObject(int16_t other) : rval(INT2FIX(other)) {}
inline RubyObject(uint16_t other) : rval(INT2FIX(other)) {}
inline RubyObject(int32_t other) : rval(INT2FIX(other)) {}
// there is no uint32_t here because that's a Ruby VALUE type, and we need the compiler to treat that as a VALUE.
inline RubyObject(int64_t other) : rval(INT2FIX(other)) {}
// inline RubyObject(uint64_t other) : rval(INT2FIX(other)) {}
/*
* Float constructor.
*
* Does not work as a template.
*/
inline RubyObject(float other) : rval(rb_float_new(other)) {}
inline RubyObject(double other) : rval(rb_float_new(other)) {}
/*
* Operators for converting RubyObjects to other C types.
*/
#define RETURN_OBJ2NUM(mac) if (this->rval == Qtrue) return 1; else if (this->rval == Qfalse) return 0; else return mac(this->rval);
inline operator int8_t() const { RETURN_OBJ2NUM(NUM2INT) }
inline operator uint8_t() const { RETURN_OBJ2NUM(NUM2UINT) }
inline operator int16_t() const { RETURN_OBJ2NUM(NUM2INT) }
inline operator uint16_t() const { RETURN_OBJ2NUM(NUM2UINT) }
inline operator int32_t() const { RETURN_OBJ2NUM(NUM2LONG) }
inline operator VALUE() const { return rval; }
//inline operator uint32_t() const { return NUM2ULONG(this->rval); }
inline operator int64_t() const { RETURN_OBJ2NUM(NUM2LONG) }
//inline operator uint64_t() const { RETURN_OBJ2NUM(NUM2ULONG) }
inline operator double() const { RETURN_OBJ2NUM(NUM2DBL) }
inline operator float() const { RETURN_OBJ2NUM(NUM2DBL) }
inline operator Complex64() const { return this->to<Complex64>(); }
inline operator Complex128() const { return this->to<Complex128>(); }
/*
* Copy constructors.
*/
inline RubyObject(const RubyObject& other) : rval(other.rval) {}
/*
* Inverse operator.
*/
inline RubyObject inverse() const {
rb_raise(rb_eNotImpError, "RubyObject#inverse needs to be implemented");
}
/*
* Absolute value.
*/
inline RubyObject abs() const {
return RubyObject(rb_funcall(this->rval, rb_intern("abs"), 0));
}
/*
* Binary operator definitions.
*/
inline RubyObject operator+(const RubyObject& other) const {
return RubyObject(rb_funcall(this->rval, nm_rb_add, 1, other.rval));
}
inline RubyObject& operator+=(const RubyObject& other) {
this->rval = rb_funcall(this->rval, nm_rb_add, 1, other.rval);
return *this;
}
inline RubyObject operator-(const RubyObject& other) const {
return RubyObject(rb_funcall(this->rval, nm_rb_sub, 1, other.rval));
}
inline RubyObject& operator-=(const RubyObject& other) {
this->rval = rb_funcall(this->rval, nm_rb_sub, 1, other.rval);
return *this;
}
inline RubyObject operator*(const RubyObject& other) const {
return RubyObject(rb_funcall(this->rval, nm_rb_mul, 1, other.rval));
}
inline RubyObject& operator*=(const RubyObject& other) {
this->rval = rb_funcall(this->rval, nm_rb_mul, 1, other.rval);
return *this;
}
inline RubyObject operator/(const RubyObject& other) const {
return RubyObject(rb_funcall(this->rval, nm_rb_div, 1, other.rval));
}
inline RubyObject& operator/=(const RubyObject& other) {
this->rval = rb_funcall(this->rval, nm_rb_div, 1, other.rval);
return *this;
}
inline RubyObject operator%(const RubyObject& other) const {
return RubyObject(rb_funcall(this->rval, nm_rb_percent, 1, other.rval));
}
inline bool operator>(const RubyObject& other) const {
return rb_funcall(this->rval, nm_rb_gt, 1, other.rval) == Qtrue;
}
inline bool operator<(const RubyObject& other) const {
return rb_funcall(this->rval, nm_rb_lt, 1, other.rval) == Qtrue;
}
template <typename OtherType>
inline bool operator<(const OtherType& other) const {
return *this < RubyObject(other);
}
inline bool operator==(const RubyObject& other) const {
return rb_funcall(this->rval, nm_rb_eql, 1, other.rval) == Qtrue;
}
template <typename OtherType>
inline bool operator==(const OtherType& other) const {
return *this == RubyObject(other);
}
inline bool operator!=(const RubyObject& other) const {
return rb_funcall(this->rval, nm_rb_neql, 1, other.rval) == Qtrue;
}
template <typename OtherType>
inline bool operator!=(const OtherType& other) const {
return *this != RubyObject(other);
}
inline bool operator>=(const RubyObject& other) const {
return rb_funcall(this->rval, nm_rb_gte, 1, other.rval) == Qtrue;
}
template <typename OtherType>
inline bool operator>=(const OtherType& other) const {
return *this >= RubyObject(other);
}
inline bool operator<=(const RubyObject& other) const {
return rb_funcall(this->rval, nm_rb_lte, 1, other.rval) == Qtrue;
}
template <typename OtherType>
inline bool operator<=(const OtherType& other) const {
return *this <= RubyObject(other);
}
////////////////////////////
// RUBY-NATIVE OPERATIONS //
////////////////////////////
/*
template <typename NativeType, typename = typename std::enable_if<std::is_arithmetic<NativeType>::value>::type>
inline bool operator==(const NativeType& other) const {
return *this == RubyObject(other);
}
template <typename NativeType, typename = typename std::enable_if<std::is_arithmetic<NativeType>::value>::type>
inline bool operator!=(const NativeType& other) const {
return *this != RubyObject(other);
}
*/
//////////////////////////////
// RUBY-COMPLEX OPERATIONS //
//////////////////////////////
template <typename FloatType, typename = typename std::enable_if<std::is_floating_point<FloatType>::value>::type>
inline bool operator==(const Complex<FloatType>& other) const {
return *this == RubyObject(other);
}
template <typename FloatType, typename = typename std::enable_if<std::is_floating_point<FloatType>::value>::type>
inline bool operator!=(const Complex<FloatType>& other) const {
return *this != RubyObject(other);
}
/*
* Convert a Ruby object to an integer.
*/
template <typename IntType>
inline typename std::enable_if<std::is_integral<IntType>::value, IntType>::type to(void) {
return NUM2INT(this->rval);
}
/*
* Convert a Ruby object to a floating point number.
*/
template <typename FloatType>
inline typename std::enable_if<std::is_floating_point<FloatType>::value, FloatType>::type to(void) {
return NUM2DBL(this->rval);
}
/*
* Convert a Ruby object to a complex number.
*/
template <typename ComplexType>
inline typename std::enable_if<made_from_same_template<ComplexType, Complex64>::value, ComplexType>::type to(void) const {
if (FIXNUM_P(this->rval) or TYPE(this->rval) == T_FLOAT) {
return ComplexType(NUM2DBL(this->rval));
} else if (TYPE(this->rval) == T_COMPLEX) {
return ComplexType(NUM2DBL(rb_funcall(this->rval, nm_rb_real, 0)), NUM2DBL(rb_funcall(this->rval, nm_rb_imag, 0)));
} else {
rb_raise(rb_eTypeError, "Invalid conversion to Complex type.");
}
}
};
// Negative operator
inline RubyObject operator-(const RubyObject& rhs) {
return RubyObject(rb_funcall(rhs.rval, nm_rb_negate, 0));
}
////////////////////////////
// NATIVE-RUBY OPERATIONS //
////////////////////////////
template <typename NativeType, typename = typename std::enable_if<std::is_arithmetic<NativeType>::value>::type>
inline RubyObject operator/(const NativeType left, const RubyObject& right) {
return RubyObject(left) / right;
}
template <typename NativeType, typename = typename std::enable_if<std::is_arithmetic<NativeType>::value>::type>
inline bool operator==(const NativeType left, const RubyObject& right) {
return RubyObject(left) == right;
}
template <typename NativeType, typename = typename std::enable_if<std::is_arithmetic<NativeType>::value>::type>
inline bool operator!=(const NativeType left, const RubyObject& right) {
return RubyObject(left) != right;
}
template <typename NativeType, typename = typename std::enable_if<std::is_arithmetic<NativeType>::value>::type>
inline bool operator<=(const NativeType left, const RubyObject& right) {
return RubyObject(left) <= right;
}
template <typename NativeType, typename = typename std::enable_if<std::is_arithmetic<NativeType>::value>::type>
inline bool operator>=(const NativeType left, const RubyObject& right) {
return RubyObject(left) >= right;
}
template <typename NativeType, typename = typename std::enable_if<std::is_arithmetic<NativeType>::value>::type>
inline bool operator<(const NativeType left, const RubyObject& right) {
return RubyObject(left) < right;
}
template <typename NativeType, typename = typename std::enable_if<std::is_arithmetic<NativeType>::value>::type>
inline bool operator>(const NativeType left, const RubyObject& right) {
return RubyObject(left) > right;
}
/////////////////////////////
// COMPLEX-RUBY OPERATIONS //
/////////////////////////////
template <typename FloatType, typename = typename std::enable_if<std::is_floating_point<FloatType>::value>::type>
inline bool operator==(const Complex<FloatType>& left, const RubyObject& right) {
return RubyObject(left) == right;
}
template <typename FloatType, typename = typename std::enable_if<std::is_floating_point<FloatType>::value>::type>
inline bool operator!=(const Complex<FloatType>& left, const RubyObject& right) {
return RubyObject(left) != right;
}
template <typename FloatType, typename = typename std::enable_if<std::is_floating_point<FloatType>::value>::type>
inline bool operator<=(const Complex<FloatType>& left, const RubyObject& right) {
return RubyObject(left) <= right;
}
template <typename FloatType, typename = typename std::enable_if<std::is_floating_point<FloatType>::value>::type>
inline bool operator>=(const Complex<FloatType>& left, const RubyObject& right) {
return RubyObject(left) >= right;
}
template <typename FloatType, typename = typename std::enable_if<std::is_floating_point<FloatType>::value>::type>
inline bool operator<(const Complex<FloatType>& left, const RubyObject& right) {
return RubyObject(left) < right;
}
template <typename FloatType, typename = typename std::enable_if<std::is_floating_point<FloatType>::value>::type>
inline bool operator>(const Complex<FloatType>& left, const RubyObject& right) {
return RubyObject(left) > right;
}
} // end of namespace nm
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
================================================
FILE: ext/nmatrix/extconf.rb
================================================
# = NMatrix
#
# A linear algebra library for scientific computation in Ruby.
# NMatrix is part of SciRuby.
#
# NMatrix was originally inspired by and derived from NArray, by
# Masahiro Tanaka: http://narray.rubyforge.org
#
# == Copyright Information
#
# SciRuby is Copyright (c) 2010 - 2014, Ruby Science Foundation
# NMatrix is Copyright (c) 2012 - 2014, John Woods and the Ruby Science Foundation
#
# Please see LICENSE.txt for additional copyright notices.
#
# == Contributing
#
# By contributing source code to SciRuby, you agree to be bound by
# our Contributor Agreement:
#
# * https://github.com/SciRuby/sciruby/wiki/Contributor-Agreement
#
# == extconf.rb
#
# This file checks for ATLAS and other necessary headers, and
# generates a Makefile for compiling NMatrix.
require File.expand_path("../../../lib/nmatrix/mkmf", __FILE__)
$INSTALLFILES = [
['nmatrix.h' , '$(archdir)'],
['nmatrix.hpp' , '$(archdir)'],
['nmatrix_config.h', '$(archdir)'],
['nm_memory.h' , '$(archdir)'],
['ruby_constants.h', '$(archdir)']
]
if /cygwin|mingw/ =~ RUBY_PLATFORM
$INSTALLFILES << ['libnmatrix.a', '$(archdir)']
end
$DEBUG = true
$CFLAGS = ["-Wall -Werror=return-type",$CFLAGS].join(" ")
$CXXFLAGS = ["-Wall -Werror=return-type",$CXXFLAGS].join(" ")
$CPPFLAGS = ["-Wall -Werror=return-type",$CPPFLAGS].join(" ")
# When adding objects here, make sure their directories are included in CLEANOBJS down at the bottom of extconf.rb.
basenames = %w{nmatrix ruby_constants data/data util/io math util/sl_list storage/common storage/storage storage/dense/dense storage/yale/yale storage/list/list}
$objs = basenames.map { |b| "#{b}.o" }
$srcs = basenames.map { |b| "#{b}.cpp" }
#$libs += " -lprofiler "
create_conf_h("nmatrix_config.h")
create_makefile("nmatrix")
Dir.mkdir("data") unless Dir.exists?("data")
Dir.mkdir("util") unless Dir.exists?("util")
Dir.mkdir("storage") unless Dir.exists?("storage")
Dir.chdir("storage") do
Dir.mkdir("yale") unless Dir.exists?("yale")
Dir.mkdir("list") unless Dir.exists?("list")
Dir.mkdir("dense") unless Dir.exists?("dense")
end
# to clean up object files in subdirectories:
open('Makefile', 'a') do |f|
clean_objs_paths = %w{data storage storage/dense storage/yale storage/list util}.map { |d| "#{d}/*.#{CONFIG["OBJEXT"]}" }
f.write("CLEANOBJS := $(CLEANOBJS) #{clean_objs_paths.join(' ')}")
end
================================================
FILE: ext/nmatrix/math/asum.h
================================================
/////////////////////////////////////////////////////////////////////
// = NMatrix
//
// A linear algebra library for scientific computation in Ruby.
// NMatrix is part of SciRuby.
//
// NMatrix was originally inspired by and derived from NArray, by
// Masahiro Tanaka: http://narray.rubyforge.org
//
// == Copyright Information
//
// SciRuby is Copyright (c) 2010 - present, Ruby Science Foundation
// NMatrix is Copyright (c) 2012 - present, John Woods and the Ruby Science Foundation
//
// Please see LICENSE.txt for additional copyright notices.
//
// == Contributing
//
// By contributing source code to SciRuby, you agree to be bound by
// our Contributor Agreement:
//
// * https://github.com/SciRuby/sciruby/wiki/Contributor-Agreement
//
// == asum.h
//
// CBLAS asum function
//
/*
* Automatically Tuned Linear Algebra Software v3.8.4
* (C) Copyright 1999 R. Clint Whaley
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions
* are met:
* 1. Redistributions of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer.
* 2. Redistributions in binary form must reproduce the above copyright
* notice, this list of conditions, and the following disclaimer in the
* documentation and/or other materials provided with the distribution.
* 3. The name of the ATLAS group or the names of its contributers may
* not be used to endorse or promote products derived from this
* software without specific written permission.
*
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
* ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
* TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
* PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE ATLAS GROUP OR ITS CONTRIBUTORS
* BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
* POSSIBILITY OF SUCH DAMAGE.
*
*/
#ifndef ASUM_H
#define ASUM_H
#include "math/magnitude.h"
namespace nm { namespace math {
/*
* Level 1 BLAS routine which sums the absolute values of a vector's contents. If the vector consists of complex values,
* the routine sums the absolute values of the real and imaginary components as well.
*
* So, based on input types, these are the valid return types:
* int -> int
* float -> float or double
* double -> double
* complex64 -> float or double
* complex128 -> double
*/
template <typename DType, typename MDType = typename MagnitudeDType<DType>::type>
inline MDType asum(const int N, const DType* X, const int incX) {
MDType sum = 0;
if ((N > 0) && (incX > 0)) {
for (int i = 0; i < N; ++i) {
sum += magnitude(X[i*incX]);
}
}
return sum;
}
template <typename DType, typename MDType = typename MagnitudeDType<DType>::type>
inline void cblas_asum(const int N, const void* X, const int incX, void* sum) {
*reinterpret_cast<MDType*>( sum ) = asum<DType,MDType>( N, reinterpret_cast<const DType*>(X), incX );
}
}} // end of namespace nm::math
#endif // ASUM_H
================================================
FILE: ext/nmatrix/math/cblas_enums.h
================================================
/////////////////////////////////////////////////////////////////////
// = NMatrix
//
// A linear algebra library for scientific computation in Ruby.
// NMatrix is part of SciRuby.
//
// NMatrix was originally inspired by and derived from NArray, by
// Masahiro Tanaka: http://narray.rubyforge.org
//
// == Copyright Information
//
// SciRuby is Copyright (c) 2010 - 2015, Ruby Science Foundation
// NMatrix is Copyright (c) 2012 - 2015, John Woods and the Ruby Science Foundation
//
// Please see LICENSE.txt for additional copyright notices.
//
// == Contributing
//
// By contributing source code to SciRuby, you agree to be bound by
// our Contributor Agreement:
//
// * https://github.com/SciRuby/sciruby/wiki/Contributor-Agreement
//
// == cblas_enums.h
//
// CBLAS definitions for when CBLAS is not available.
//
#ifndef CBLAS_ENUM_DEFINED_H
#define CBLAS_ENUM_DEFINED_H
enum CBLAS_ORDER {CblasRowMajor=101, CblasColMajor=102};
enum CBLAS_TRANSPOSE {CblasNoTrans=111, CblasTrans=112, CblasConjTrans=113};
enum CBLAS_UPLO {CblasUpper=121, CblasLower=122};
enum CBLAS_DIAG {CblasNonUnit=131, CblasUnit=132};
enum CBLAS_SIDE {CblasLeft=141, CblasRight=142};
#endif
================================================
FILE: ext/nmatrix/math/cblas_templates_core.h
================================================
/////////////////////////////////////////////////////////////////////
// = NMatrix
//
// A linear algebra library for scientific computation in Ruby.
// NMatrix is part of SciRuby.
//
// NMatrix was originally inspired by and derived from NArray, by
// Masahiro Tanaka: http://narray.rubyforge.org
//
// == Copyright Information
//
// SciRuby is Copyright (c) 2010 - 2014, Ruby Science Foundation
// NMatrix is Copyright (c) 2012 - 2014, John Woods and the Ruby Science Foundation
//
// Please se
gitextract_ehxqtovs/ ├── .gitignore ├── .rspec ├── .travis.yml ├── CONTRIBUTING.md ├── Gemfile ├── History.txt ├── LICENSE.txt ├── Manifest.txt ├── README.rdoc ├── Rakefile ├── ext/ │ ├── nmatrix/ │ │ ├── binary_format.txt │ │ ├── data/ │ │ │ ├── complex.h │ │ │ ├── data.cpp │ │ │ ├── data.h │ │ │ ├── meta.h │ │ │ └── ruby_object.h │ │ ├── extconf.rb │ │ ├── math/ │ │ │ ├── asum.h │ │ │ ├── cblas_enums.h │ │ │ ├── cblas_templates_core.h │ │ │ ├── gemm.h │ │ │ ├── gemv.h │ │ │ ├── getrf.h │ │ │ ├── getrs.h │ │ │ ├── imax.h │ │ │ ├── laswp.h │ │ │ ├── long_dtype.h │ │ │ ├── magnitude.h │ │ │ ├── math.h │ │ │ ├── nrm2.h │ │ │ ├── rot.h │ │ │ ├── rotg.h │ │ │ ├── scal.h │ │ │ ├── trsm.h │ │ │ └── util.h │ │ ├── math.cpp │ │ ├── nm_memory.h │ │ ├── nmatrix.cpp │ │ ├── nmatrix.h │ │ ├── ruby_constants.cpp │ │ ├── ruby_constants.h │ │ ├── ruby_nmatrix.c │ │ ├── storage/ │ │ │ ├── common.cpp │ │ │ ├── common.h │ │ │ ├── dense/ │ │ │ │ ├── dense.cpp │ │ │ │ └── dense.h │ │ │ ├── list/ │ │ │ │ ├── list.cpp │ │ │ │ └── list.h │ │ │ ├── storage.cpp │ │ │ ├── storage.h │ │ │ └── yale/ │ │ │ ├── class.h │ │ │ ├── iterators/ │ │ │ │ ├── base.h │ │ │ │ ├── iterator.h │ │ │ │ ├── row.h │ │ │ │ ├── row_stored.h │ │ │ │ ├── row_stored_nd.h │ │ │ │ └── stored_diagonal.h │ │ │ ├── math/ │ │ │ │ └── transpose.h │ │ │ ├── yale.cpp │ │ │ └── yale.h │ │ ├── types.h │ │ └── util/ │ │ ├── io.cpp │ │ ├── io.h │ │ ├── sl_list.cpp │ │ ├── sl_list.h │ │ └── util.h │ ├── nmatrix_atlas/ │ │ ├── extconf.rb │ │ ├── math_atlas/ │ │ │ ├── cblas_templates_atlas.h │ │ │ ├── clapack_templates.h │ │ │ ├── geev.h │ │ │ ├── gesdd.h │ │ │ ├── gesvd.h │ │ │ └── inc.h │ │ ├── math_atlas.cpp │ │ └── nmatrix_atlas.cpp │ ├── nmatrix_fftw/ │ │ ├── extconf.rb │ │ └── nmatrix_fftw.cpp │ ├── nmatrix_java/ │ │ ├── nmatrix/ │ │ │ ├── math/ │ │ │ │ └── MathHelper.java │ │ │ ├── storage/ │ │ │ │ └── dense/ │ │ │ │ └── ArrayComparator.java │ │ │ └── util/ │ │ │ ├── ArrayGenerator.java │ │ │ ├── MatrixGenerator.java │ │ │ └── WrapperType.java │ │ └── test/ │ │ ├── AssertTests.java │ │ └── TestRunner.java │ └── nmatrix_lapacke/ │ ├── extconf.rb │ ├── lapacke/ │ │ ├── include/ │ │ │ ├── lapacke.h │ │ │ ├── lapacke_config.h │ │ │ ├── lapacke_mangling.h │ │ │ ├── lapacke_mangling_with_flags.h │ │ │ └── lapacke_utils.h │ │ ├── src/ │ │ │ ├── lapacke_cgeev.c │ │ │ ├── lapacke_cgeev_work.c │ │ │ ├── lapacke_cgeqrf.c │ │ │ ├── lapacke_cgeqrf_work.c │ │ │ ├── lapacke_cgesdd.c │ │ │ ├── lapacke_cgesdd_work.c │ │ │ ├── lapacke_cgesvd.c │ │ │ ├── lapacke_cgesvd_work.c │ │ │ ├── lapacke_cgetrf.c │ │ │ ├── lapacke_cgetrf_work.c │ │ │ ├── lapacke_cgetri.c │ │ │ ├── lapacke_cgetri_work.c │ │ │ ├── lapacke_cgetrs.c │ │ │ ├── lapacke_cgetrs_work.c │ │ │ ├── lapacke_cpotrf.c │ │ │ ├── lapacke_cpotrf_work.c │ │ │ ├── lapacke_cpotri.c │ │ │ ├── lapacke_cpotri_work.c │ │ │ ├── lapacke_cpotrs.c │ │ │ ├── lapacke_cpotrs_work.c │ │ │ ├── lapacke_cunmqr.c │ │ │ ├── lapacke_cunmqr_work.c │ │ │ ├── lapacke_dgeev.c │ │ │ ├── lapacke_dgeev_work.c │ │ │ ├── lapacke_dgeqrf.c │ │ │ ├── lapacke_dgeqrf_work.c │ │ │ ├── lapacke_dgesdd.c │ │ │ ├── lapacke_dgesdd_work.c │ │ │ ├── lapacke_dgesvd.c │ │ │ ├── lapacke_dgesvd_work.c │ │ │ ├── lapacke_dgetrf.c │ │ │ ├── lapacke_dgetrf_work.c │ │ │ ├── lapacke_dgetri.c │ │ │ ├── lapacke_dgetri_work.c │ │ │ ├── lapacke_dgetrs.c │ │ │ ├── lapacke_dgetrs_work.c │ │ │ ├── lapacke_dormqr.c │ │ │ ├── lapacke_dormqr_work.c │ │ │ ├── lapacke_dpotrf.c │ │ │ ├── lapacke_dpotrf_work.c │ │ │ ├── lapacke_dpotri.c │ │ │ ├── lapacke_dpotri_work.c │ │ │ ├── lapacke_dpotrs.c │ │ │ ├── lapacke_dpotrs_work.c │ │ │ ├── lapacke_sgeev.c │ │ │ ├── lapacke_sgeev_work.c │ │ │ ├── lapacke_sgeqrf.c │ │ │ ├── lapacke_sgeqrf_work.c │ │ │ ├── lapacke_sgesdd.c │ │ │ ├── lapacke_sgesdd_work.c │ │ │ ├── lapacke_sgesvd.c │ │ │ ├── lapacke_sgesvd_work.c │ │ │ ├── lapacke_sgetrf.c │ │ │ ├── lapacke_sgetrf_work.c │ │ │ ├── lapacke_sgetri.c │ │ │ ├── lapacke_sgetri_work.c │ │ │ ├── lapacke_sgetrs.c │ │ │ ├── lapacke_sgetrs_work.c │ │ │ ├── lapacke_sormqr.c │ │ │ ├── lapacke_sormqr_work.c │ │ │ ├── lapacke_spotrf.c │ │ │ ├── lapacke_spotrf_work.c │ │ │ ├── lapacke_spotri.c │ │ │ ├── lapacke_spotri_work.c │ │ │ ├── lapacke_spotrs.c │ │ │ ├── lapacke_spotrs_work.c │ │ │ ├── lapacke_zgeev.c │ │ │ ├── lapacke_zgeev_work.c │ │ │ ├── lapacke_zgeqrf.c │ │ │ ├── lapacke_zgeqrf_work.c │ │ │ ├── lapacke_zgesdd.c │ │ │ ├── lapacke_zgesdd_work.c │ │ │ ├── lapacke_zgesvd.c │ │ │ ├── lapacke_zgesvd_work.c │ │ │ ├── lapacke_zgetrf.c │ │ │ ├── lapacke_zgetrf_work.c │ │ │ ├── lapacke_zgetri.c │ │ │ ├── lapacke_zgetri_work.c │ │ │ ├── lapacke_zgetrs.c │ │ │ ├── lapacke_zgetrs_work.c │ │ │ ├── lapacke_zpotrf.c │ │ │ ├── lapacke_zpotrf_work.c │ │ │ ├── lapacke_zpotri.c │ │ │ ├── lapacke_zpotri_work.c │ │ │ ├── lapacke_zpotrs.c │ │ │ ├── lapacke_zpotrs_work.c │ │ │ ├── lapacke_zunmqr.c │ │ │ └── lapacke_zunmqr_work.c │ │ └── utils/ │ │ ├── lapacke_c_nancheck.c │ │ ├── lapacke_cge_nancheck.c │ │ ├── lapacke_cge_trans.c │ │ ├── lapacke_cpo_nancheck.c │ │ ├── lapacke_cpo_trans.c │ │ ├── lapacke_ctr_nancheck.c │ │ ├── lapacke_ctr_trans.c │ │ ├── lapacke_d_nancheck.c │ │ ├── lapacke_dge_nancheck.c │ │ ├── lapacke_dge_trans.c │ │ ├── lapacke_dpo_nancheck.c │ │ ├── lapacke_dpo_trans.c │ │ ├── lapacke_dtr_nancheck.c │ │ ├── lapacke_dtr_trans.c │ │ ├── lapacke_lsame.c │ │ ├── lapacke_s_nancheck.c │ │ ├── lapacke_sge_nancheck.c │ │ ├── lapacke_sge_trans.c │ │ ├── lapacke_spo_nancheck.c │ │ ├── lapacke_spo_trans.c │ │ ├── lapacke_str_nancheck.c │ │ ├── lapacke_str_trans.c │ │ ├── lapacke_xerbla.c │ │ ├── lapacke_z_nancheck.c │ │ ├── lapacke_zge_nancheck.c │ │ ├── lapacke_zge_trans.c │ │ ├── lapacke_zpo_nancheck.c │ │ ├── lapacke_zpo_trans.c │ │ ├── lapacke_ztr_nancheck.c │ │ └── lapacke_ztr_trans.c │ ├── lapacke.cpp │ ├── lapacke_nmatrix.h │ ├── make_lapacke_cpp.rb │ ├── math_lapacke/ │ │ ├── cblas_local.h │ │ ├── cblas_templates_lapacke.h │ │ └── lapacke_templates.h │ ├── math_lapacke.cpp │ └── nmatrix_lapacke.cpp ├── lib/ │ ├── nmatrix/ │ │ ├── atlas.rb │ │ ├── blas.rb │ │ ├── cruby/ │ │ │ └── math.rb │ │ ├── enumerate.rb │ │ ├── fftw.rb │ │ ├── homogeneous.rb │ │ ├── io/ │ │ │ ├── fortran_format.rb │ │ │ ├── harwell_boeing.rb │ │ │ ├── market.rb │ │ │ ├── mat5_reader.rb │ │ │ ├── mat_reader.rb │ │ │ └── point_cloud.rb │ │ ├── jruby/ │ │ │ ├── decomposition.rb │ │ │ ├── enumerable.rb │ │ │ ├── error.rb │ │ │ ├── math.rb │ │ │ ├── nmatrix_java.rb │ │ │ ├── operators.rb │ │ │ └── slice.rb │ │ ├── lapack_core.rb │ │ ├── lapack_ext_common.rb │ │ ├── lapack_plugin.rb │ │ ├── lapacke.rb │ │ ├── math.rb │ │ ├── mkmf.rb │ │ ├── monkeys.rb │ │ ├── nmatrix.rb │ │ ├── rspec.rb │ │ ├── shortcuts.rb │ │ ├── version.rb │ │ └── yale_functions.rb │ └── nmatrix.rb ├── nmatrix-atlas.gemspec ├── nmatrix-fftw.gemspec ├── nmatrix-lapacke.gemspec ├── nmatrix.gemspec ├── scripts/ │ ├── benchmarks/ │ │ └── nmatrix_creation.rb │ ├── switch_lapack_ubuntu.rb │ └── ttable_helper.rb ├── spec/ │ ├── 00_nmatrix_spec.rb │ ├── 01_enum_spec.rb │ ├── 02_slice_spec.rb │ ├── 03_nmatrix_monkeys_spec.rb │ ├── 2x2_dense_double.mat │ ├── 4x4_sparse.mat │ ├── 4x5_dense.mat │ ├── blas_spec.rb │ ├── elementwise_spec.rb │ ├── homogeneous_spec.rb │ ├── io/ │ │ ├── fortran_format_spec.rb │ │ ├── harwell_boeing_spec.rb │ │ └── test.rua │ ├── io_spec.rb │ ├── lapack_core_spec.rb │ ├── leakcheck.rb │ ├── math_spec.rb │ ├── nmatrix_yale_resize_test_associations.yaml │ ├── nmatrix_yale_spec.rb │ ├── plugins/ │ │ ├── atlas/ │ │ │ └── atlas_spec.rb │ │ ├── fftw/ │ │ │ └── fftw_spec.rb │ │ └── lapacke/ │ │ └── lapacke_spec.rb │ ├── rspec_monkeys.rb │ ├── rspec_spec.rb │ ├── shortcuts_spec.rb │ ├── slice_set_spec.rb │ ├── spec_helper.rb │ ├── stat_spec.rb │ └── test.pcd └── travis.sh
SYMBOL INDEX (1556 symbols across 224 files)
FILE: ext/nmatrix/data/complex.h
function namespace (line 53) | namespace nm {
function namespace (line 363) | namespace std {
FILE: ext/nmatrix/data/data.cpp
type nm (line 46) | namespace nm {
function rubyobj_from_cval (line 99) | nm::RubyObject rubyobj_from_cval(void* val, nm::dtype_t dtype) {
function rubyval_to_cval (line 198) | void rubyval_to_cval(VALUE val, nm::dtype_t dtype, void* loc) {
function nm_init_data (line 266) | void nm_init_data() {
FILE: ext/nmatrix/data/data.h
function namespace (line 49) | namespace nm {
FILE: ext/nmatrix/data/meta.h
function namespace (line 31) | namespace nm {
FILE: ext/nmatrix/data/ruby_object.h
function namespace (line 54) | namespace nm {
function namespace (line 374) | namespace std {
FILE: ext/nmatrix/math.cpp
type nm (line 191) | namespace nm {
type math (line 192) | namespace math {
function det_exact_from_dense (line 198) | void det_exact_from_dense(const int M, const void* A_elements, const...
function det_exact_from_yale (line 229) | void det_exact_from_yale(const int M, const YALE_STORAGE* storage, c...
function solve (line 286) | void solve(const int r, const void* lu_elements, const void* b_eleme...
function inverse (line 324) | void inverse(const int M, void* a_elements) {
function hessenberg (line 407) | void hessenberg(const int nrows, void* a_elements) {
function raise_not_invertible_error (line 467) | void raise_not_invertible_error() {
function inverse_exact_from_dense (line 476) | void inverse_exact_from_dense(const int M, const void* A_elements,
function inverse_exact_from_yale (line 513) | void inverse_exact_from_yale(const int M, const YALE_STORAGE* storage,
function cblas_gemm (line 625) | inline static void cblas_gemm(const enum CBLAS_ORDER order,
function cblas_gemv (line 647) | inline static bool cblas_gemv(const enum CBLAS_TRANSPOSE trans,
function cblas_trsm (line 669) | inline static void cblas_trsm(const enum CBLAS_ORDER order, const en...
function nm_math_init_blas (line 688) | void nm_math_init_blas() {
function VALUE (line 729) | static VALUE nm_cblas_scal(VALUE self, VALUE n, VALUE alpha, VALUE vecto...
function VALUE (line 766) | static VALUE nm_cblas_rotg(VALUE self, VALUE ab) {
function VALUE (line 834) | static VALUE nm_cblas_rot(VALUE self, VALUE n, VALUE x, VALUE incx, VALU...
function VALUE (line 895) | static VALUE nm_cblas_nrm2(VALUE self, VALUE n, VALUE x, VALUE incx) {
function VALUE (line 945) | static VALUE nm_cblas_asum(VALUE self, VALUE n, VALUE x, VALUE incx) {
function VALUE (line 987) | static VALUE nm_cblas_imax(VALUE self, VALUE n, VALUE x, VALUE incx) {
function VALUE (line 1020) | static VALUE nm_cblas_gemm(VALUE self,
function VALUE (line 1066) | static VALUE nm_cblas_gemv(VALUE self,
function VALUE (line 1088) | static VALUE nm_cblas_trsm(VALUE self,
function VALUE (line 1147) | static VALUE nm_clapack_getrf(VALUE self, VALUE order, VALUE m, VALUE n,...
function VALUE (line 1184) | static VALUE nm_clapack_getrs(VALUE self, VALUE order, VALUE trans, VALU...
function VALUE (line 1224) | static VALUE nm_has_clapack(VALUE self) {
function VALUE (line 1234) | static VALUE nm_clapack_laswp(VALUE self, VALUE n, VALUE a, VALUE lda, V...
function nm_math_det_exact_from_dense (line 1270) | void nm_math_det_exact_from_dense(const int M, const void* elements, con...
function nm_math_det_exact_from_yale (line 1281) | void nm_math_det_exact_from_yale(const int M, const YALE_STORAGE* storag...
function nm_math_solve (line 1292) | void nm_math_solve(VALUE lu, VALUE b, VALUE x, VALUE ipiv) {
function nm_math_hessenberg (line 1308) | void nm_math_hessenberg(VALUE a) {
function nm_math_inverse (line 1322) | void nm_math_inverse(const int M, void* a_elements, nm::dtype_t dtype) {
function nm_math_inverse_exact_from_dense (line 1331) | void nm_math_inverse_exact_from_dense(const int M, const void* A_elements,
function nm_math_inverse_exact_from_yale (line 1343) | void nm_math_inverse_exact_from_yale(const int M, const YALE_STORAGE* st...
function nm_math_transpose_generic (line 1355) | void nm_math_transpose_generic(const size_t M, const size_t N, const voi...
FILE: ext/nmatrix/math/asum.h
function namespace (line 65) | namespace nm { namespace math {
FILE: ext/nmatrix/math/cblas_enums.h
type CBLAS_ORDER (line 31) | enum CBLAS_ORDER {CblasRowMajor=101, CblasColMajor=102}
type CBLAS_TRANSPOSE (line 32) | enum CBLAS_TRANSPOSE {CblasNoTrans=111, CblasTrans=112, CblasConjTrans=113}
type CBLAS_UPLO (line 33) | enum CBLAS_UPLO {CblasUpper=121, CblasLower=122}
type CBLAS_DIAG (line 34) | enum CBLAS_DIAG {CblasNonUnit=131, CblasUnit=132}
type CBLAS_SIDE (line 35) | enum CBLAS_SIDE {CblasLeft=141, CblasRight=142}
FILE: ext/nmatrix/math/cblas_templates_core.h
function rotg (line 54) | inline void rotg(float* a, float* b, float* c, float* s) {
function rotg (line 59) | inline void rotg(double* a, double* b, double* c, double* s) {
function rot (line 84) | inline void rot(const int N, float* X, const int incX, float* Y, const i...
function rot (line 89) | inline void rot(const int N, double* X, const int incX, double* Y, const...
function asum (line 117) | inline float asum(const int N, const float* X, const int incX) {
function asum (line 122) | inline double asum(const int N, const double* X, const int incX) {
function asum (line 127) | inline float asum(const int N, const Complex64* X, const int incX) {
function asum (line 132) | inline double asum(const int N, const Complex128* X, const int incX) {
function nrm2 (line 159) | inline float nrm2(const int N, const float* X, const int incX) {
function nrm2 (line 164) | inline double nrm2(const int N, const double* X, const int incX) {
function nrm2 (line 169) | inline float nrm2(const int N, const Complex64* X, const int incX) {
function nrm2 (line 174) | inline double nrm2(const int N, const Complex128* X, const int incX) {
function imax (line 190) | inline int imax(const int n, const float* x, const int incx) {
function imax (line 195) | inline int imax(const int n, const double* x, const int incx) {
function imax (line 200) | inline int imax(const int n, const Complex64* x, const int incx) {
function imax (line 205) | inline int imax(const int n, const Complex128* x, const int incx) {
function scal (line 221) | inline void scal(const int n, const float scalar, float* x, const int in...
function scal (line 226) | inline void scal(const int n, const double scalar, double* x, const int ...
function scal (line 231) | inline void scal(const int n, const Complex64 scalar, Complex64* x, cons...
function scal (line 236) | inline void scal(const int n, const Complex128 scalar, Complex128* x, co...
function gemv (line 253) | inline bool gemv(const enum CBLAS_TRANSPOSE Trans, const int M, const in...
function gemv (line 260) | inline bool gemv(const enum CBLAS_TRANSPOSE Trans, const int M, const in...
function gemv (line 267) | inline bool gemv(const enum CBLAS_TRANSPOSE Trans, const int M, const in...
function gemv (line 274) | inline bool gemv(const enum CBLAS_TRANSPOSE Trans, const int M, const in...
function cblas_gemv (line 281) | bool cblas_gemv(const enum CBLAS_TRANSPOSE trans,
function gemm (line 305) | inline void gemm(const enum CBLAS_ORDER Order, const enum CBLAS_TRANSPOS...
function gemm (line 311) | inline void gemm(const enum CBLAS_ORDER Order, const enum CBLAS_TRANSPOS...
function gemm (line 317) | inline void gemm(const enum CBLAS_ORDER Order, const enum CBLAS_TRANSPOS...
function gemm (line 323) | inline void gemm(const enum CBLAS_ORDER Order, const enum CBLAS_TRANSPOS...
function cblas_gemm (line 329) | void cblas_gemm(const enum CBLAS_ORDER order,
function trsm (line 356) | inline void trsm(const enum CBLAS_ORDER order, const enum CBLAS_SIDE sid...
function trsm (line 365) | inline void trsm(const enum CBLAS_ORDER order, const enum CBLAS_SIDE sid...
function trsm (line 375) | inline void trsm(const enum CBLAS_ORDER order, const enum CBLAS_SIDE sid...
function trsm (line 384) | inline void trsm(const enum CBLAS_ORDER order, const enum CBLAS_SIDE sid...
function cblas_trsm (line 393) | void cblas_trsm(const enum CBLAS_ORDER order, const enum CBLAS_SIDE side...
FILE: ext/nmatrix/math/gemm.h
function namespace (line 36) | namespace nm { namespace math {
FILE: ext/nmatrix/math/gemv.h
function namespace (line 35) | namespace nm { namespace math {
FILE: ext/nmatrix/math/getrf.h
function namespace (line 69) | namespace nm { namespace math {
FILE: ext/nmatrix/math/getrs.h
function namespace (line 62) | namespace nm { namespace math {
FILE: ext/nmatrix/math/imax.h
function namespace (line 34) | namespace nm { namespace math {
FILE: ext/nmatrix/math/laswp.h
function namespace (line 61) | namespace nm { namespace math {
FILE: ext/nmatrix/math/long_dtype.h
function namespace (line 33) | namespace nm { namespace math {
FILE: ext/nmatrix/math/magnitude.h
function namespace (line 35) | namespace nm { namespace math {
FILE: ext/nmatrix/math/math.h
function namespace (line 116) | namespace nm {
FILE: ext/nmatrix/math/nrm2.h
function namespace (line 65) | namespace nm { namespace math {
FILE: ext/nmatrix/math/rot.h
function namespace (line 62) | namespace nm { namespace math {
FILE: ext/nmatrix/math/rotg.h
function namespace (line 62) | namespace nm { namespace math {
FILE: ext/nmatrix/math/scal.h
function namespace (line 32) | namespace nm { namespace math {
FILE: ext/nmatrix/math/trsm.h
function namespace (line 62) | namespace nm { namespace math {
FILE: ext/nmatrix/math/util.h
function blas_transpose_sym (line 40) | static inline enum CBLAS_TRANSPOSE blas_transpose_sym(VALUE op) {
function lapacke_transpose_sym (line 52) | static inline char lapacke_transpose_sym(VALUE op) {
function blas_side_sym (line 65) | static inline enum CBLAS_SIDE blas_side_sym(VALUE op) {
function lapacke_side_sym (line 79) | static inline char lapacke_side_sym(VALUE op) {
function blas_uplo_sym (line 92) | static inline enum CBLAS_UPLO blas_uplo_sym(VALUE op) {
function lapacke_uplo_sym (line 105) | static inline char lapacke_uplo_sym(VALUE op) {
function blas_diag_sym (line 118) | static inline enum CBLAS_DIAG blas_diag_sym(VALUE op) {
function blas_order_sym (line 130) | static inline enum CBLAS_ORDER blas_order_sym(VALUE op) {
function lapack_svd_job_sym (line 143) | static inline char lapack_svd_job_sym(VALUE op) {
function lapack_evd_job_sym (line 157) | static inline char lapack_evd_job_sym(VALUE op) {
FILE: ext/nmatrix/nmatrix.cpp
type nm (line 70) | namespace nm {
function write_padded_dense_elements_upper (line 76) | size_t write_padded_dense_elements_upper(std::ofstream& f, DENSE_STORA...
function write_padded_dense_elements_herm (line 98) | size_t write_padded_dense_elements_herm(std::ofstream& f, DENSE_STORAG...
function read_padded_dense_elements_herm (line 113) | void read_padded_dense_elements_herm(DType* elements, size_t length) {
function read_padded_dense_elements_herm (line 118) | void read_padded_dense_elements_herm(Complex64* elements, size_t lengt...
function read_padded_dense_elements_herm (line 127) | void read_padded_dense_elements_herm(Complex128* elements, size_t leng...
function read_padded_dense_elements (line 141) | void read_padded_dense_elements(std::ifstream& f, DENSE_STORAGE* stora...
function write_padded_yale_elements (line 207) | void write_padded_yale_elements(std::ofstream& f, YALE_STORAGE* storag...
function read_padded_yale_elements (line 229) | void read_padded_yale_elements(std::ifstream& f, YALE_STORAGE* storage...
function write_padded_dense_elements (line 248) | void write_padded_dense_elements(std::ofstream& f, DENSE_STORAGE* stor...
FILE: ext/nmatrix/nmatrix.h
function VALUE (line 94) | static inline const VALUE *
type VALUE (line 421) | typedef VALUE (*METHOD)(...);
FILE: ext/nmatrix/ruby_constants.cpp
function nm_init_ruby_constants (line 102) | void nm_init_ruby_constants(void) {
FILE: ext/nmatrix/ruby_nmatrix.c
function Init_nmatrix (line 181) | void Init_nmatrix() {
function VALUE (line 410) | static VALUE nm_alloc(VALUE klass) {
function VALUE (line 426) | static VALUE nm_capacity(VALUE self) {
function nm_mark (line 456) | void nm_mark(NMATRIX* mat) {
function nm_delete (line 465) | void nm_delete(NMATRIX* mat) {
function nm_delete_ref (line 479) | void nm_delete_ref(NMATRIX* mat) {
function __nm_mark_value_container (line 502) | static void __nm_mark_value_container(NM_GC_HOLDER* gc_value_holder_stru...
function __nm_initialize_value_container (line 516) | static void __nm_initialize_value_container() {
function nm_register_values (line 532) | void nm_register_values(VALUE* values, size_t n) {
function nm_unregister_values (line 554) | void nm_unregister_values(VALUE* values, size_t n) {
function nm_register_value (line 583) | void nm_register_value(VALUE* val) {
function nm_unregister_value (line 590) | void nm_unregister_value(VALUE* val) {
function nm_completely_unregister_value (line 600) | void nm_completely_unregister_value(VALUE* val) {
function nm_register_storage (line 634) | void nm_register_storage(nm::stype_t stype, const STORAGE* storage) {
function nm_unregister_storage (line 647) | void nm_unregister_storage(nm::stype_t stype, const STORAGE* storage) {
function nm_register_nmatrix (line 655) | void nm_register_nmatrix(NMATRIX* nmatrix) {
function nm_unregister_nmatrix (line 663) | void nm_unregister_nmatrix(NMATRIX* nmatrix) {
function VALUE (line 676) | static VALUE nm_dtype(VALUE self) {
function VALUE (line 690) | static VALUE nm_upcast(VALUE self, VALUE t1, VALUE t2) {
function VALUE (line 705) | static VALUE nm_default_value(VALUE self) {
function VALUE (line 724) | static VALUE nm_each_with_indices(VALUE nmatrix) {
function VALUE (line 755) | static VALUE nm_each_stored_with_indices(VALUE nmatrix) {
function VALUE (line 787) | static VALUE nm_map_stored(VALUE nmatrix) {
function VALUE (line 817) | static VALUE nm_each_ordered_stored_with_indices(VALUE nmatrix) {
function VALUE (line 851) | static VALUE nm_eqeq(VALUE left, VALUE right) {
function VALUE (line 952) | static VALUE nm_unary_log(int argc, VALUE* argv, VALUE self) {
function VALUE (line 977) | static VALUE nm_unary_round(int argc, VALUE* argv, VALUE self) {
function VALUE (line 1016) | static VALUE nm_hermitian(VALUE self) {
function VALUE (line 1029) | static VALUE nm_complex_conjugate_bang(VALUE self) {
function VALUE (line 1076) | static VALUE nm_reshape_bang(VALUE self, VALUE arg){
function VALUE (line 1133) | static VALUE nm_init_new_version(int argc, VALUE* argv, VALUE self) {
function VALUE (line 1344) | static VALUE nm_init(int argc, VALUE* argv, VALUE nm) {
function NMATRIX (line 1468) | NMATRIX* nm_cast_with_ctype_args(NMATRIX* self, nm::stype_t new_stype, n...
function VALUE (line 1487) | VALUE nm_cast_with_types(VALUE self, nm::stype_t new_stype, nm::dtype_t ...
function VALUE (line 1509) | VALUE nm_cast(VALUE self, VALUE new_stype_symbol, VALUE new_dtype_symbol...
function VALUE (line 1531) | static VALUE nm_init_transposed(VALUE self) {
function VALUE (line 1554) | static VALUE nm_init_copy(VALUE copy, VALUE original) {
function get_version_info (line 1587) | static void get_version_info(uint16_t& major, uint16_t& minor, uint16_t&...
function nm (line 1601) | static nm::symm_t interpret_symm(VALUE symm) {
function read_padded_shape (line 1623) | void read_padded_shape(std::ifstream& f, size_t dim, size_t* shape) {
function write_padded_shape (line 1640) | void write_padded_shape(std::ofstream& f, size_t dim, size_t* shape) {
function read_padded_yale_elements (line 1661) | void read_padded_yale_elements(std::ifstream& f, YALE_STORAGE* storage, ...
function write_padded_yale_elements (line 1668) | void write_padded_yale_elements(std::ofstream& f, YALE_STORAGE* storage,...
function read_padded_dense_elements (line 1675) | void read_padded_dense_elements(std::ifstream& f, DENSE_STORAGE* storage...
function write_padded_dense_elements (line 1682) | void write_padded_dense_elements(std::ofstream& f, DENSE_STORAGE* storag...
function VALUE (line 1694) | static VALUE rb_get_errno_exc(const char* which) {
function VALUE (line 1707) | static VALUE nm_write(int argc, VALUE* argv, VALUE self) {
function VALUE (line 1812) | static VALUE nm_read(int argc, VALUE* argv, VALUE self) {
function VALUE (line 1931) | static VALUE nm_init_yale_from_old_yale(VALUE shape, VALUE dtype, VALUE ...
function VALUE (line 1952) | static VALUE nm_is_ref(VALUE self) {
function VALUE (line 1967) | static VALUE nm_mget(int argc, VALUE* argv, VALUE self) {
function VALUE (line 1987) | static VALUE nm_mref(int argc, VALUE* argv, VALUE self) {
function VALUE (line 2006) | static VALUE nm_mset(int argc, VALUE* argv, VALUE self) {
function VALUE (line 2048) | static VALUE nm_multiply(VALUE left_v, VALUE right_v) {
function VALUE (line 2123) | static VALUE nm_dim(VALUE self) {
function VALUE (line 2133) | static VALUE nm_shape(VALUE self) {
function VALUE (line 2155) | static VALUE nm_offset(VALUE self) {
function VALUE (line 2177) | static VALUE nm_supershape(VALUE self) {
function VALUE (line 2203) | static VALUE nm_stype(VALUE self) {
function VALUE (line 2216) | static VALUE nm_symmetric(VALUE self) {
function effective_dim (line 2224) | static size_t effective_dim(STORAGE* s) {
function VALUE (line 2239) | static VALUE nm_effective_dim(VALUE self) {
function VALUE (line 2247) | static VALUE nm_xslice(int argc, VALUE* argv, void* (*slice_func)(const ...
function VALUE (line 2300) | static VALUE unary_op(nm::unaryop_t op, VALUE self) {
function check_dims_and_shape (line 2322) | static void check_dims_and_shape(VALUE left_val, VALUE right_val) {
function VALUE (line 2333) | static VALUE elementwise_op(nm::ewop_t op, VALUE left_val, VALUE right_v...
function VALUE (line 2410) | static VALUE noncom_elementwise_op(nm::noncom_ewop_t op, VALUE self, VAL...
function is_ref (line 2486) | bool is_ref(const NMATRIX* matrix) {
function VALUE (line 2493) | static VALUE is_symmetric(VALUE self, bool hermitian) {
function VALUE (line 2529) | static VALUE nm_guess_dtype(VALUE self, VALUE v) {
function VALUE (line 2536) | static VALUE nm_min_dtype(VALUE self, VALUE v) {
function else (line 2615) | else if (RB_TYPE_P(v, T_ARRAY))
function init_slice_no_alloc (line 2633) | static void init_slice_no_alloc(SLICE* slice, size_t dim, int argc, VALU...
function get_time (line 2702) | static double get_time(void) {
function nm (line 2717) | static nm::dtype_t interpret_dtype(int argc, VALUE* argv, nm::stype_t st...
function nm (line 2811) | static nm::stype_t interpret_stype(VALUE arg) {
function STORAGE (line 2827) | STORAGE* matrix_storage_cast_alloc(NMATRIX* matrix, nm::dtype_t new_dtyp...
function STORAGE_PAIR (line 2835) | STORAGE_PAIR binary_storage_cast_alloc(NMATRIX* left_matrix, NMATRIX* ri...
function VALUE (line 2853) | static VALUE matrix_multiply_scalar(NMATRIX* left, VALUE scalar) {
function VALUE (line 2858) | static VALUE matrix_multiply(NMATRIX* left, NMATRIX* right) {
function VALUE (line 2922) | static VALUE nm_hessenberg(VALUE self, VALUE a) {
function VALUE (line 2934) | static VALUE nm_inverse(VALUE self, VALUE inverse, VALUE bang) {
function VALUE (line 2964) | static VALUE nm_inverse_exact(VALUE self, VALUE inverse, VALUE lda, VALU...
function VALUE (line 3007) | static VALUE nm_det_exact(VALUE self) {
function VALUE (line 3050) | static VALUE nm_data_pointer(VALUE self) {
function VALUE (line 3076) | VALUE rb_nmatrix_dense_create(nm::dtype_t dtype, size_t* shape, size_t d...
function VALUE (line 3127) | VALUE rb_nvector_dense_create(nm::dtype_t dtype, void* elements, size_t ...
FILE: ext/nmatrix/storage/common.cpp
function nm_storage_count_max_elements (line 59) | size_t nm_storage_count_max_elements(const STORAGE* storage) {
function VALUE (line 72) | VALUE nm_enumerator_length(VALUE nmatrix) {
FILE: ext/nmatrix/storage/common.h
type STORAGE_PAIR (line 61) | struct STORAGE_PAIR {
type SLICE (line 66) | struct SLICE {
function namespace (line 85) | namespace nm {
FILE: ext/nmatrix/storage/dense/dense.cpp
type nm (line 57) | namespace nm { namespace dense_storage {
type dense_storage (line 57) | namespace dense_storage {
function slice_copy (line 82) | static void slice_copy(DENSE_STORAGE *dest, const DENSE_STORAGE *src...
function slice_set (line 105) | static void slice_set(DENSE_STORAGE* dest, size_t* lengths, size_t p...
function set (line 125) | void set(VALUE left, SLICE* slice, VALUE right) {
function ref_slice_copy_transposed (line 908) | void ref_slice_copy_transposed(const DENSE_STORAGE* rhs, DENSE_STORA...
function DENSE_STORAGE (line 932) | DENSE_STORAGE* cast_copy(const DENSE_STORAGE* rhs, dtype_t new_dtype) {
function eqeq (line 970) | bool eqeq(const DENSE_STORAGE* left, const DENSE_STORAGE* right) {
function is_hermitian (line 1019) | bool is_hermitian(const DENSE_STORAGE* mat, int lda) {
function is_symmetric (line 1040) | bool is_symmetric(const DENSE_STORAGE* mat, int lda) {
function DENSE_STORAGE (line 1061) | static DENSE_STORAGE* matrix_multiply(const STORAGE_PAIR& casted_sto...
function interpret_arg_as_dense_nmatrix (line 876) | std::pair<NMATRIX*,bool> interpret_arg_as_dense_nmatrix(VALUE right, n...
type dense_storage (line 901) | namespace dense_storage {
function slice_copy (line 82) | static void slice_copy(DENSE_STORAGE *dest, const DENSE_STORAGE *src...
function slice_set (line 105) | static void slice_set(DENSE_STORAGE* dest, size_t* lengths, size_t p...
function set (line 125) | void set(VALUE left, SLICE* slice, VALUE right) {
function ref_slice_copy_transposed (line 908) | void ref_slice_copy_transposed(const DENSE_STORAGE* rhs, DENSE_STORA...
function DENSE_STORAGE (line 932) | DENSE_STORAGE* cast_copy(const DENSE_STORAGE* rhs, dtype_t new_dtype) {
function eqeq (line 970) | bool eqeq(const DENSE_STORAGE* left, const DENSE_STORAGE* right) {
function is_hermitian (line 1019) | bool is_hermitian(const DENSE_STORAGE* mat, int lda) {
function is_symmetric (line 1040) | bool is_symmetric(const DENSE_STORAGE* mat, int lda) {
function DENSE_STORAGE (line 1061) | static DENSE_STORAGE* matrix_multiply(const STORAGE_PAIR& casted_sto...
function DENSE_STORAGE (line 205) | static DENSE_STORAGE* nm_dense_storage_create_dummy(nm::dtype_t dtype, s...
function DENSE_STORAGE (line 231) | DENSE_STORAGE* nm_dense_storage_create(nm::dtype_t dtype, size_t* shape,...
function nm_dense_storage_delete (line 276) | void nm_dense_storage_delete(STORAGE* s) {
function nm_dense_storage_delete_ref (line 295) | void nm_dense_storage_delete_ref(STORAGE* s) {
function nm_dense_storage_mark (line 309) | void nm_dense_storage_mark(STORAGE* storage_base) {
function nm_dense_storage_register (line 332) | void nm_dense_storage_register(const STORAGE* s) {
function nm_dense_storage_unregister (line 346) | void nm_dense_storage_unregister(const STORAGE* s) {
function VALUE (line 362) | VALUE nm_dense_map_pair(VALUE self, VALUE right) {
function VALUE (line 417) | VALUE nm_dense_map(VALUE self) {
function VALUE (line 466) | VALUE nm_dense_each_with_indices(VALUE nmatrix) {
function VALUE (line 518) | VALUE nm_dense_each(VALUE nmatrix) {
function slice_copy (line 566) | static void slice_copy(DENSE_STORAGE *dest, const DENSE_STORAGE *src, si...
function nm_dense_storage_set (line 644) | void nm_dense_storage_set(VALUE left, SLICE* slice, VALUE right) {
function nm_dense_storage_eqeq (line 662) | bool nm_dense_storage_eqeq(const STORAGE* left, const STORAGE* right) {
function nm_dense_storage_is_hermitian (line 677) | bool nm_dense_storage_is_hermitian(const DENSE_STORAGE* mat, int lda) {
function nm_dense_storage_is_symmetric (line 692) | bool nm_dense_storage_is_symmetric(const DENSE_STORAGE* mat, int lda) {
function STORAGE (line 706) | STORAGE* nm_dense_storage_matrix_multiply(const STORAGE_PAIR& casted_sto...
function nm_dense_storage_pos (line 720) | size_t nm_dense_storage_pos(const DENSE_STORAGE* s, const size_t* coords) {
function nm_dense_storage_coords (line 737) | void nm_dense_storage_coords(const DENSE_STORAGE* s, const size_t slice_...
function STORAGE (line 772) | STORAGE* nm_dense_storage_cast_copy(const STORAGE* rhs, nm::dtype_t new_...
function DENSE_STORAGE (line 786) | DENSE_STORAGE* nm_dense_storage_copy(const DENSE_STORAGE* rhs) {
function STORAGE (line 832) | STORAGE* nm_dense_storage_copy_transposed(const STORAGE* rhs_base) {
type nm (line 868) | namespace nm {
type dense_storage (line 57) | namespace dense_storage {
function slice_copy (line 82) | static void slice_copy(DENSE_STORAGE *dest, const DENSE_STORAGE *src...
function slice_set (line 105) | static void slice_set(DENSE_STORAGE* dest, size_t* lengths, size_t p...
function set (line 125) | void set(VALUE left, SLICE* slice, VALUE right) {
function ref_slice_copy_transposed (line 908) | void ref_slice_copy_transposed(const DENSE_STORAGE* rhs, DENSE_STORA...
function DENSE_STORAGE (line 932) | DENSE_STORAGE* cast_copy(const DENSE_STORAGE* rhs, dtype_t new_dtype) {
function eqeq (line 970) | bool eqeq(const DENSE_STORAGE* left, const DENSE_STORAGE* right) {
function is_hermitian (line 1019) | bool is_hermitian(const DENSE_STORAGE* mat, int lda) {
function is_symmetric (line 1040) | bool is_symmetric(const DENSE_STORAGE* mat, int lda) {
function DENSE_STORAGE (line 1061) | static DENSE_STORAGE* matrix_multiply(const STORAGE_PAIR& casted_sto...
function interpret_arg_as_dense_nmatrix (line 876) | std::pair<NMATRIX*,bool> interpret_arg_as_dense_nmatrix(VALUE right, n...
type dense_storage (line 901) | namespace dense_storage {
function slice_copy (line 82) | static void slice_copy(DENSE_STORAGE *dest, const DENSE_STORAGE *src...
function slice_set (line 105) | static void slice_set(DENSE_STORAGE* dest, size_t* lengths, size_t p...
function set (line 125) | void set(VALUE left, SLICE* slice, VALUE right) {
function ref_slice_copy_transposed (line 908) | void ref_slice_copy_transposed(const DENSE_STORAGE* rhs, DENSE_STORA...
function DENSE_STORAGE (line 932) | DENSE_STORAGE* cast_copy(const DENSE_STORAGE* rhs, dtype_t new_dtype) {
function eqeq (line 970) | bool eqeq(const DENSE_STORAGE* left, const DENSE_STORAGE* right) {
function is_hermitian (line 1019) | bool is_hermitian(const DENSE_STORAGE* mat, int lda) {
function is_symmetric (line 1040) | bool is_symmetric(const DENSE_STORAGE* mat, int lda) {
function DENSE_STORAGE (line 1061) | static DENSE_STORAGE* matrix_multiply(const STORAGE_PAIR& casted_sto...
FILE: ext/nmatrix/storage/dense/dense.h
function namespace (line 125) | namespace nm {
FILE: ext/nmatrix/storage/list/list.cpp
type nm (line 68) | namespace nm { namespace list_storage {
type list_storage (line 68) | namespace list_storage {
class RecurseData (line 74) | class RecurseData {
method RecurseData (line 77) | RecurseData(const LIST_STORAGE* s, VALUE init_obj__ = Qnil) : ref(...
method dtype_t (line 99) | dtype_t dtype() const { return ref->dtype; }
method dim (line 102) | size_t dim() const { return ref->dim; }
method ref_shape (line 104) | size_t ref_shape(size_t rec) const {
method actual_shape (line 114) | size_t actual_shape(size_t rec) const {
method offset (line 118) | size_t offset(size_t rec) const {
method VALUE (line 126) | VALUE init_obj() const { return init_obj_; }
method LIST (line 128) | LIST* top_level_list() const {
function map_empty_stored_r (line 157) | static void map_empty_stored_r(RecurseData& result, RecurseData& s, ...
function map_stored_r (line 229) | static void map_stored_r(RecurseData& result, RecurseData& left, LIS...
function map_merged_stored_r (line 296) | static void map_merged_stored_r(RecurseData& result, RecurseData& le...
function slice_set (line 405) | static bool slice_set(LIST_STORAGE* dest, LIST* l, size_t* coords, s...
function set (line 537) | void set(VALUE left, SLICE* slice, VALUE right) {
function init_default (line 601) | void init_default(LIST_STORAGE* s) {
function LIST_STORAGE (line 1472) | static LIST_STORAGE* cast_copy(const LIST_STORAGE* rhs, dtype_t new_...
function eqeq_empty_r (line 1508) | static bool eqeq_empty_r(RecurseData& s, const LIST* l, size_t rec, ...
function eqeq_r (line 1541) | static bool eqeq_r(RecurseData& left, RecurseData& right, const LIST...
type list_storage (line 1465) | namespace list_storage {
class RecurseData (line 74) | class RecurseData {
method RecurseData (line 77) | RecurseData(const LIST_STORAGE* s, VALUE init_obj__ = Qnil) : ref(...
method dtype_t (line 99) | dtype_t dtype() const { return ref->dtype; }
method dim (line 102) | size_t dim() const { return ref->dim; }
method ref_shape (line 104) | size_t ref_shape(size_t rec) const {
method actual_shape (line 114) | size_t actual_shape(size_t rec) const {
method offset (line 118) | size_t offset(size_t rec) const {
method VALUE (line 126) | VALUE init_obj() const { return init_obj_; }
method LIST (line 128) | LIST* top_level_list() const {
function map_empty_stored_r (line 157) | static void map_empty_stored_r(RecurseData& result, RecurseData& s, ...
function map_stored_r (line 229) | static void map_stored_r(RecurseData& result, RecurseData& left, LIS...
function map_merged_stored_r (line 296) | static void map_merged_stored_r(RecurseData& result, RecurseData& le...
function slice_set (line 405) | static bool slice_set(LIST_STORAGE* dest, LIST* l, size_t* coords, s...
function set (line 537) | void set(VALUE left, SLICE* slice, VALUE right) {
function init_default (line 601) | void init_default(LIST_STORAGE* s) {
function LIST_STORAGE (line 1472) | static LIST_STORAGE* cast_copy(const LIST_STORAGE* rhs, dtype_t new_...
function eqeq_empty_r (line 1508) | static bool eqeq_empty_r(RecurseData& s, const LIST* l, size_t rec, ...
function eqeq_r (line 1541) | static bool eqeq_r(RecurseData& left, RecurseData& right, const LIST...
function LIST_STORAGE (line 628) | LIST_STORAGE* nm_list_storage_create(nm::dtype_t dtype, size_t* shape, s...
function nm_list_storage_delete (line 654) | void nm_list_storage_delete(STORAGE* s) {
function nm_list_storage_delete_ref (line 671) | void nm_list_storage_delete_ref(STORAGE* s) {
function nm_list_storage_mark (line 685) | void nm_list_storage_mark(STORAGE* storage_base) {
function __nm_list_storage_unregister_temp_value_list (line 694) | static void __nm_list_storage_unregister_temp_value_list(std::list<VALUE...
function __nm_list_storage_unregister_temp_list_list (line 700) | static void __nm_list_storage_unregister_temp_list_list(std::list<LIST*>...
function nm_list_storage_register_node (line 706) | void nm_list_storage_register_node(const NODE* curr) {
function nm_list_storage_unregister_node (line 710) | void nm_list_storage_unregister_node(const NODE* curr) {
function nm_list_storage_completely_unregister_node (line 721) | void nm_list_storage_completely_unregister_node(const NODE* curr) {
function nm_list_storage_register_list (line 725) | void nm_list_storage_register_list(const LIST* list, size_t recursions) {
function nm_list_storage_unregister_list (line 741) | void nm_list_storage_unregister_list(const LIST* list, size_t recursions) {
function nm_list_storage_register (line 757) | void nm_list_storage_register(const STORAGE* s) {
function nm_list_storage_unregister (line 765) | void nm_list_storage_unregister(const STORAGE* s) {
function NODE (line 780) | static NODE* list_storage_get_single_node(LIST_STORAGE* s, SLICE* slice) {
function each_empty_with_indices_r (line 799) | static void each_empty_with_indices_r(nm::list_storage::RecurseData& s, ...
function each_with_indices_r (line 825) | static void each_with_indices_r(nm::list_storage::RecurseData& s, const ...
function each_stored_with_indices_r (line 877) | static void each_stored_with_indices_r(nm::list_storage::RecurseData& s,...
function VALUE (line 928) | VALUE nm_list_each_with_indices(VALUE nmatrix, bool stored) {
function VALUE (line 953) | VALUE nm_list_map_stored(VALUE left, VALUE init) {
function VALUE (line 1003) | VALUE nm_list_map_merged_stored(VALUE left, VALUE right, VALUE init) {
function LIST (line 1076) | static LIST* slice_copy(const LIST_STORAGE* src, LIST* src_rows, size_t*...
function slice_set_single (line 1197) | static void slice_set_single(LIST_STORAGE* dest, LIST* l, void* val, siz...
function nm_list_storage_set (line 1261) | void nm_list_storage_set(VALUE left, SLICE* slice, VALUE right) {
function NODE (line 1274) | NODE* nm_list_storage_insert(STORAGE* storage, SLICE* slice, void* val) {
function nm_list_storage_remove (line 1302) | void nm_list_storage_remove(STORAGE* storage, SLICE* slice) {
function nm_list_storage_eqeq (line 1318) | bool nm_list_storage_eqeq(const STORAGE* left, const STORAGE* right) {
function STORAGE (line 1335) | STORAGE* nm_list_storage_matrix_multiply(const STORAGE_PAIR& casted_stor...
function VALUE (line 1349) | VALUE nm_list_storage_to_hash(const LIST_STORAGE* s, const nm::dtype_t d...
function nm_list_storage_count_elements_r (line 1365) | size_t nm_list_storage_count_elements_r(const LIST* l, size_t recursions) {
function nm_list_storage_count_nd_elements (line 1388) | size_t nm_list_storage_count_nd_elements(const LIST_STORAGE* s) {
function LIST_STORAGE (line 1419) | LIST_STORAGE* nm_list_storage_copy(const LIST_STORAGE* rhs) {
function STORAGE (line 1440) | STORAGE* nm_list_storage_cast_copy(const STORAGE* rhs, nm::dtype_t new_d...
function STORAGE (line 1450) | STORAGE* nm_list_storage_copy_transposed(const STORAGE* rhs_base) {
type nm (line 1464) | namespace nm {
type list_storage (line 68) | namespace list_storage {
class RecurseData (line 74) | class RecurseData {
method RecurseData (line 77) | RecurseData(const LIST_STORAGE* s, VALUE init_obj__ = Qnil) : ref(...
method dtype_t (line 99) | dtype_t dtype() const { return ref->dtype; }
method dim (line 102) | size_t dim() const { return ref->dim; }
method ref_shape (line 104) | size_t ref_shape(size_t rec) const {
method actual_shape (line 114) | size_t actual_shape(size_t rec) const {
method offset (line 118) | size_t offset(size_t rec) const {
method VALUE (line 126) | VALUE init_obj() const { return init_obj_; }
method LIST (line 128) | LIST* top_level_list() const {
function map_empty_stored_r (line 157) | static void map_empty_stored_r(RecurseData& result, RecurseData& s, ...
function map_stored_r (line 229) | static void map_stored_r(RecurseData& result, RecurseData& left, LIS...
function map_merged_stored_r (line 296) | static void map_merged_stored_r(RecurseData& result, RecurseData& le...
function slice_set (line 405) | static bool slice_set(LIST_STORAGE* dest, LIST* l, size_t* coords, s...
function set (line 537) | void set(VALUE left, SLICE* slice, VALUE right) {
function init_default (line 601) | void init_default(LIST_STORAGE* s) {
function LIST_STORAGE (line 1472) | static LIST_STORAGE* cast_copy(const LIST_STORAGE* rhs, dtype_t new_...
function eqeq_empty_r (line 1508) | static bool eqeq_empty_r(RecurseData& s, const LIST* l, size_t rec, ...
function eqeq_r (line 1541) | static bool eqeq_r(RecurseData& left, RecurseData& right, const LIST...
type list_storage (line 1465) | namespace list_storage {
class RecurseData (line 74) | class RecurseData {
method RecurseData (line 77) | RecurseData(const LIST_STORAGE* s, VALUE init_obj__ = Qnil) : ref(...
method dtype_t (line 99) | dtype_t dtype() const { return ref->dtype; }
method dim (line 102) | size_t dim() const { return ref->dim; }
method ref_shape (line 104) | size_t ref_shape(size_t rec) const {
method actual_shape (line 114) | size_t actual_shape(size_t rec) const {
method offset (line 118) | size_t offset(size_t rec) const {
method VALUE (line 126) | VALUE init_obj() const { return init_obj_; }
method LIST (line 128) | LIST* top_level_list() const {
function map_empty_stored_r (line 157) | static void map_empty_stored_r(RecurseData& result, RecurseData& s, ...
function map_stored_r (line 229) | static void map_stored_r(RecurseData& result, RecurseData& left, LIS...
function map_merged_stored_r (line 296) | static void map_merged_stored_r(RecurseData& result, RecurseData& le...
function slice_set (line 405) | static bool slice_set(LIST_STORAGE* dest, LIST* l, size_t* coords, s...
function set (line 537) | void set(VALUE left, SLICE* slice, VALUE right) {
function init_default (line 601) | void init_default(LIST_STORAGE* s) {
function LIST_STORAGE (line 1472) | static LIST_STORAGE* cast_copy(const LIST_STORAGE* rhs, dtype_t new_...
function eqeq_empty_r (line 1508) | static bool eqeq_empty_r(RecurseData& s, const LIST* l, size_t rec, ...
function eqeq_r (line 1541) | static bool eqeq_r(RecurseData& left, RecurseData& right, const LIST...
function VALUE (line 1612) | VALUE nm_to_hash(VALUE self) {
function VALUE (line 1622) | VALUE nm_list_default_value(VALUE self) {
FILE: ext/nmatrix/storage/list/list.h
function nm_list_storage_count_elements (line 118) | inline size_t nm_list_storage_count_elements(const LIST_STORAGE* s) {
FILE: ext/nmatrix/storage/storage.cpp
type nm (line 64) | namespace nm {
type dense_storage (line 75) | namespace dense_storage {
function DENSE_STORAGE (line 89) | DENSE_STORAGE* create_from_list_storage(const LIST_STORAGE* rhs, dty...
function DENSE_STORAGE (line 129) | DENSE_STORAGE* create_from_yale_storage(const YALE_STORAGE* rhs, dty...
function cast_copy_list_contents (line 210) | static void cast_copy_list_contents(LDType* lhs, const LIST* rhs, RD...
function cast_copy_list_default (line 246) | static void cast_copy_list_default(LDType* lhs, RDType* default_val,...
type list_storage (line 260) | namespace list_storage {
function LIST_STORAGE (line 270) | LIST_STORAGE* create_from_dense_storage(const DENSE_STORAGE* rhs, dt...
function LIST_STORAGE (line 328) | LIST_STORAGE* create_from_yale_storage(const YALE_STORAGE* rhs, dtyp...
function cast_copy_contents_dense (line 434) | static bool cast_copy_contents_dense(LIST* lhs, const RDType* rhs, R...
type yale_storage (line 487) | namespace yale_storage { // FIXME: Move to yale.cpp
function YALE_STORAGE (line 492) | YALE_STORAGE* create_from_dense_storage(const DENSE_STORAGE* rhs, dt...
function YALE_STORAGE (line 575) | YALE_STORAGE* create_from_list_storage(const LIST_STORAGE* rhs, nm::...
function STORAGE (line 659) | STORAGE* nm_yale_storage_from_dense(const STORAGE* right, nm::dtype_t l_...
function STORAGE (line 670) | STORAGE* nm_yale_storage_from_list(const STORAGE* right, nm::dtype_t l_d...
function STORAGE (line 681) | STORAGE* nm_dense_storage_from_list(const STORAGE* right, nm::dtype_t l_...
function STORAGE (line 692) | STORAGE* nm_dense_storage_from_yale(const STORAGE* right, nm::dtype_t l_...
function STORAGE (line 705) | STORAGE* nm_list_storage_from_dense(const STORAGE* right, nm::dtype_t l_...
function STORAGE (line 716) | STORAGE* nm_list_storage_from_yale(const STORAGE* right, nm::dtype_t l_d...
FILE: ext/nmatrix/storage/storage.h
function namespace (line 72) | namespace nm {
FILE: ext/nmatrix/storage/yale/class.h
function namespace (line 36) | namespace nm {
function iterator (line 235) | iterator row_end(size_t row) { return begin(...
function iterator (line 236) | iterator end() { return iterat...
function const_iterator (line 238) | const_iterator crow_end(size_t row) const { return cbegin...
function stored_diagonal_iterator (line 242) | stored_diagonal_iterator sdend() {
function row_iterator (line 250) | row_iterator riend() { return row_it...
function class (line 291) | class multi_row_insertion_plan {
function multi_row_insertion_plan (line 311) | multi_row_insertion_plan insertion_plan(row_iterator i, size_t j, size_t...
function insert (line 330) | void insert(row_iterator i, size_t j, size_t* lengths, D* const v, size_...
function insert (line 363) | void insert(SLICE* slice, VALUE right) {
function row_iterator (line 420) | row_iterator erase(row_iterator it, const row_stored_nd_iterator& positi...
function row_iterator (line 430) | row_iterator erase(row_iterator it, const row_stored_iterator& jt) {
function row_iterator (line 436) | row_iterator insert(row_iterator it, row_stored_iterator position, size_...
function row_iterator (line 452) | row_iterator insert(row_iterator it, row_stored_nd_iterator position, si...
function stored_diagonal_iterator (line 469) | stored_diagonal_iterator insert(stored_diagonal_iterator position, const...
function D (line 498) | inline D* get_single_p(SLICE* slice) {
function YALE_STORAGE (line 524) | YALE_STORAGE* alloc_ref(SLICE* slice) {
function YALE_STORAGE (line 574) | static YALE_STORAGE* create(size_t* shape, size_t reserve) {
function init (line 621) | static void init(YALE_STORAGE& s, D* init_val) {
function update_resize_move_insert (line 952) | void update_resize_move_insert(size_t real_i, size_t real_j, size_t* len...
function update_resize_move (line 1045) | void update_resize_move(row_stored_nd_iterator position, size_t real_i, ...
function move_right (line 1111) | void move_right(row_stored_nd_iterator position, size_t n) {
function move_left (line 1123) | void move_left(row_stored_nd_iterator position, size_t n) {
FILE: ext/nmatrix/storage/yale/iterators/base.h
function namespace (line 37) | namespace nm {
FILE: ext/nmatrix/storage/yale/iterators/iterator.h
function namespace (line 36) | namespace nm { namespace yale_storage {
FILE: ext/nmatrix/storage/yale/iterators/row.h
function namespace (line 37) | namespace nm { namespace yale_storage {
FILE: ext/nmatrix/storage/yale/iterators/row_stored_nd.h
function namespace (line 37) | namespace yale_storage {
FILE: ext/nmatrix/storage/yale/math/transpose.h
function namespace (line 32) | namespace nm { namespace yale_storage {
FILE: ext/nmatrix/storage/yale/yale.cpp
function src_ndnz (line 108) | static inline size_t src_ndnz(const YALE_STORAGE* s) {
type nm (line 114) | namespace nm { namespace yale_storage {
type yale_storage (line 114) | namespace yale_storage {
function IType (line 144) | static inline IType* IJA(const YALE_STORAGE* s) {
function IType (line 148) | static inline IType IJA_SET(const YALE_STORAGE* s, size_t loc, IType...
function DType (line 153) | static inline DType* A(const YALE_STORAGE* s) {
function DType (line 158) | static inline DType A_SET(const YALE_STORAGE* s, size_t loc, DType v...
function copy_recast_vector (line 171) | static inline void copy_recast_vector(const void* in_, void* out_, s...
function YALE_STORAGE (line 189) | YALE_STORAGE* create_from_old_yale(dtype_t dtype, size_t* shape, cha...
function init (line 269) | void init(YALE_STORAGE* s, void* init_val) {
function YALE_STORAGE (line 283) | static YALE_STORAGE* slice_copy(YALE_STORAGE* s) {
function YALE_STORAGE (line 297) | YALE_STORAGE* copy_transposed(YALE_STORAGE* rhs) {
function count_slice_copy_ndnz (line 312) | static size_t count_slice_copy_ndnz(const YALE_STORAGE* s, size_t* o...
function YALE_STORAGE (line 361) | YALE_STORAGE* ref(YALE_STORAGE* s, SLICE* slice) {
function set (line 370) | void set(VALUE left, SLICE* slice, VALUE right) {
function eqeq (line 384) | static bool eqeq(const YALE_STORAGE* left, const YALE_STORAGE* right) {
function IType (line 406) | IType binary_search_left_boundary(const YALE_STORAGE* s, IType left,...
function binary_search (line 428) | int binary_search(YALE_STORAGE* s, IType left, IType right, IType ke...
function vector_grow (line 452) | static void vector_grow(YALE_STORAGE* s) {
function vector_insert_resize (line 492) | static char vector_insert_resize(YALE_STORAGE* s, size_t current_siz...
function vector_insert (line 571) | static char vector_insert(YALE_STORAGE* s, size_t pos, size_t* j, vo...
function increment_ia_after (line 630) | static void increment_ia_after(YALE_STORAGE* s, IType ija_size, ITyp...
function IType (line 642) | static IType insert_search(YALE_STORAGE* s, IType left, IType right,...
function YALE_STORAGE (line 673) | YALE_STORAGE* cast_copy(const YALE_STORAGE* rhs) {
function get_size (line 681) | size_t get_size(const YALE_STORAGE* storage) {
function STORAGE (line 687) | static STORAGE* matrix_multiply(const STORAGE_PAIR& casted_storage, ...
function get_offsets (line 733) | static std::array<size_t,2> get_offsets(YALE_STORAGE* x) {
class RowIterator (line 744) | class RowIterator {
method RowIterator (line 754) | RowIterator(YALE_STORAGE* s_, IType* ija_, IType i_, size_t j_shap...
method RowIterator (line 768) | RowIterator(YALE_STORAGE* s_, IType i_, size_t j_shape_, size_t j_...
method RowIterator (line 782) | RowIterator(const RowIterator& rhs) : s(rhs.s), ija(rhs.ija), a(re...
method VALUE (line 784) | VALUE obj() const {
method T (line 789) | T cobj() const {
method IType (line 794) | inline IType proper_j() const {
method IType (line 798) | inline IType offset_j() const {
method capacity (line 802) | inline size_t capacity() const {
method vector_grow (line 806) | inline void vector_grow() {
method insert (line 814) | bool insert(IType j, VALUE v) {
method update_row_end (line 833) | void update_row_end() {
method end (line 839) | inline bool end() const {
method row_has_no_nd (line 846) | inline bool row_has_no_nd() const { return ija[i] == k_end; /* k_s...
method diag_is_first (line 847) | inline bool diag_is_first() const { return i < ija[ija[i]]; }
method diag_is_last (line 848) | inline bool diag_is_last() const { return i > ija[k_end-1]; }
method k_is_last_nd (line 849) | inline bool k_is_last_nd() const { return k == k_end-1; }
method k_is_last (line 850) | inline bool k_is_last() const { return k_is_last_nd() && !diag...
method diag_is_ahead (line 851) | inline bool diag_is_ahead() const { return i > ija[k]; }
method row_has_diag (line 852) | inline bool row_has_diag() const { return i < s->shape[1]; }
method diag_is_next (line 853) | inline bool diag_is_next() const { // assumes we've already teste...
method RowIterator (line 859) | RowIterator& operator++() {
method RowIterator (line 883) | RowIterator operator++(int unused) {
function VALUE (line 893) | static VALUE nm_yale_stored_enumerator_length(VALUE nmatrix) {
function VALUE (line 907) | static VALUE nm_yale_stored_nondiagonal_enumerator_length(VALUE nmat...
function VALUE (line 919) | static VALUE nm_yale_stored_diagonal_enumerator_length(VALUE nmatrix) {
function VALUE (line 929) | static VALUE nm_yale_enumerator_length(VALUE nmatrix) {
function VALUE (line 942) | static VALUE map_stored(VALUE self) {
function VALUE (line 965) | static VALUE map_merged_stored(VALUE left, VALUE right, VALUE init) {
function VALUE (line 977) | static VALUE each_stored_with_indices(VALUE nm) {
function VALUE (line 1007) | static VALUE stored_diagonal_each_with_indices(VALUE nm) {
function VALUE (line 1032) | static VALUE stored_nondiagonal_each_with_indices(VALUE nm) {
function VALUE (line 1059) | static VALUE each_ordered_stored_with_indices(VALUE nm) {
function VALUE (line 1083) | static VALUE each_with_indices(VALUE nm) {
function is_pos_default_value (line 1104) | static bool is_pos_default_value(YALE_STORAGE* s, size_t apos) {
function nm_init_yale_functions (line 1121) | void nm_init_yale_functions() {
function VALUE (line 1167) | VALUE nm_yale_each_with_indices(VALUE nmatrix) {
function VALUE (line 1175) | VALUE nm_yale_each_stored_with_indices(VALUE nmatrix) {
function VALUE (line 1183) | VALUE nm_yale_stored_diagonal_each_with_indices(VALUE nmatrix) {
function VALUE (line 1190) | VALUE nm_yale_stored_nondiagonal_each_with_indices(VALUE nmatrix) {
function VALUE (line 1198) | VALUE nm_yale_each_ordered_stored_with_indices(VALUE nmatrix) {
function nm_yale_storage_set (line 1209) | void nm_yale_storage_set(VALUE left, SLICE* slice, VALUE right) {
function yale_count_slice_copy_ndnz (line 1219) | static size_t yale_count_slice_copy_ndnz(const YALE_STORAGE* s, size_t* ...
function nm_yale_storage_vector_insert (line 1260) | static char nm_yale_storage_vector_insert(YALE_STORAGE* s, size_t pos, s...
function nm_yale_storage_increment_ia_after (line 1269) | static void nm_yale_storage_increment_ia_after(YALE_STORAGE* s, size_t i...
function nm_yale_storage_eqeq (line 1297) | bool nm_yale_storage_eqeq(const STORAGE* left, const STORAGE* right) {
function STORAGE (line 1309) | STORAGE* nm_yale_storage_cast_copy(const STORAGE* rhs, nm::dtype_t new_d...
function nm_yale_storage_get_size (line 1321) | size_t nm_yale_storage_get_size(const YALE_STORAGE* storage) {
function VALUE (line 1337) | static VALUE obj_at(YALE_STORAGE* s, size_t k) {
function VALUE (line 1346) | static VALUE default_value(const YALE_STORAGE* s) {
function default_value_is_numeric_zero (line 1355) | static bool default_value_is_numeric_zero(const YALE_STORAGE* s) {
function STORAGE (line 1364) | STORAGE* nm_yale_storage_copy_transposed(const STORAGE* rhs_base) {
function STORAGE (line 1376) | STORAGE* nm_yale_storage_matrix_multiply(const STORAGE_PAIR& casted_stor...
function YALE_STORAGE (line 1403) | YALE_STORAGE* nm_yale_storage_create(nm::dtype_t dtype, size_t* shape, s...
function nm_yale_storage_delete (line 1414) | void nm_yale_storage_delete(STORAGE* s) {
function nm_yale_storage_delete_ref (line 1430) | void nm_yale_storage_delete_ref(STORAGE* s) {
function nm_yale_storage_init (line 1445) | void nm_yale_storage_init(YALE_STORAGE* s, void* init_val) {
function nm_yale_storage_mark (line 1455) | void nm_yale_storage_mark(STORAGE* storage_base) {
function nm_yale_storage_register_a (line 1465) | void nm_yale_storage_register_a(void* a, size_t size) {
function nm_yale_storage_unregister_a (line 1469) | void nm_yale_storage_unregister_a(void* a, size_t size) {
function nm_yale_storage_register (line 1473) | void nm_yale_storage_register(const STORAGE* s) {
function nm_yale_storage_unregister (line 1480) | void nm_yale_storage_unregister(const STORAGE* s) {
function YALE_STORAGE (line 1492) | static YALE_STORAGE* alloc(nm::dtype_t dtype, size_t* shape, size_t dim) {
function YALE_STORAGE (line 1510) | YALE_STORAGE* nm_yale_storage_create_from_old_yale(nm::dtype_t dtype, si...
function VALUE (line 1529) | static VALUE nm_size(VALUE self) {
function is_pos_default_value (line 1539) | static bool is_pos_default_value(YALE_STORAGE* s, size_t apos) {
function VALUE (line 1556) | static VALUE nm_row_keys_intersection(VALUE m1, VALUE ii1, VALUE m2, VAL...
function VALUE (line 1645) | static VALUE nm_a(int argc, VALUE* argv, VALUE self) {
function VALUE (line 1696) | static VALUE nm_d(int argc, VALUE* argv, VALUE self) {
function VALUE (line 1738) | static VALUE nm_lu(VALUE self) {
function VALUE (line 1777) | static VALUE nm_ia(VALUE self) {
function VALUE (line 1800) | static VALUE nm_ja(VALUE self) {
function VALUE (line 1834) | static VALUE nm_ija(int argc, VALUE* argv, VALUE self) {
function VALUE (line 1886) | static VALUE nm_nd_row(int argc, VALUE* argv, VALUE self) {
function VALUE (line 1968) | VALUE nm_vector_set(int argc, VALUE* argv, VALUE self) { //, VALUE i_, V...
function VALUE (line 2044) | VALUE nm_yale_default_value(VALUE self) {
function VALUE (line 2056) | VALUE nm_yale_map_merged_stored(VALUE left, VALUE right, VALUE init) {
function VALUE (line 2069) | VALUE nm_yale_map_stored(VALUE self) {
FILE: ext/nmatrix/storage/yale/yale.h
function namespace (line 153) | namespace nm {
FILE: ext/nmatrix/types.h
type float32_t (line 50) | typedef float float32_t;
type float64_t (line 51) | typedef double float64_t;
type IType (line 53) | typedef size_t IType;
FILE: ext/nmatrix/util/io.cpp
type nm (line 32) | namespace nm { namespace io {
type io (line 32) | namespace io {
function nm_dtype_from_rbstring (line 104) | nm::dtype_t nm_dtype_from_rbstring(VALUE str) {
function nm_dtype_from_rbsymbol (line 119) | nm::dtype_t nm_dtype_from_rbsymbol(VALUE sym) {
function nm_stype_from_rbstring (line 137) | nm::stype_t nm_stype_from_rbstring(VALUE str) {
function nm_stype_from_rbsymbol (line 152) | nm::stype_t nm_stype_from_rbsymbol(VALUE sym) {
function matlab_dtype_from_rbsymbol (line 169) | static nm::io::matlab_dtype_t matlab_dtype_from_rbsymbol(VALUE sym) {
function VALUE (line 191) | static VALUE nm_rbstring_matlab_repack(VALUE self, VALUE str, VALUE from...
function VALUE (line 236) | static VALUE nm_rbstring_merge(VALUE self, VALUE rb_real, VALUE rb_imagi...
function nm_init_io (line 269) | void nm_init_io() {
FILE: ext/nmatrix/util/io.h
function namespace (line 45) | namespace nm { namespace io {
FILE: ext/nmatrix/util/sl_list.cpp
type nm (line 46) | namespace nm { namespace list {
type list (line 46) | namespace list {
function LIST (line 76) | LIST* create(void) {
function del (line 87) | void del(LIST* list, size_t recursions) {
function mark (line 114) | void mark(LIST* list, size_t recursions) {
function NODE (line 141) | NODE* insert_first_node(LIST* list, size_t key, void* val, size_t va...
function NODE (line 155) | NODE* insert_first_list(LIST* list, size_t key, LIST* l) {
function NODE (line 173) | NODE* insert(LIST* list, bool replace, size_t key, void* val) {
function NODE (line 226) | NODE* insert_after(NODE* node, size_t key, void* val) {
function NODE (line 245) | NODE* replace_insert_after(NODE* node, size_t key, void* val, bool c...
function NODE (line 275) | NODE* insert_copy(LIST *list, bool replace, size_t key, void *val, s...
function node_is_within_slice (line 342) | bool node_is_within_slice(NODE* n, size_t coord, size_t len) {
function remove_recursive (line 352) | bool remove_recursive(LIST* list, const size_t* coords, const size_t...
function NODE (line 411) | NODE* find(LIST* list, size_t key) {
function NODE (line 433) | NODE* find_with_preceding(LIST* list, size_t key, NODE*& prev) {
function NODE (line 457) | NODE* find_preceding_from_node(NODE* prev, size_t key) {
function NODE (line 473) | NODE* find_preceding_from_list(LIST* l, size_t key) {
function NODE (line 483) | NODE* find_nearest(LIST* list, size_t key) {
function NODE (line 490) | NODE* find_nearest_from(NODE* prev, size_t key) {
function cast_copy_contents (line 519) | void cast_copy_contents(LIST* lhs, const LIST* rhs, size_t recursion...
function nm_list_cast_copy_contents (line 572) | void nm_list_cast_copy_contents(LIST* lhs, const LIST* rhs, nm::dtype_t ...
function VALUE (line 584) | static VALUE empty_list_to_hash(const nm::dtype_t dtype, size_t recursio...
function VALUE (line 598) | VALUE nm_list_copy_to_hash(const LIST* l, const nm::dtype_t dtype, size_...
FILE: ext/nmatrix/util/sl_list.h
function namespace (line 50) | namespace nm { namespace list {
FILE: ext/nmatrix/util/util.h
function namespace (line 56) | namespace nm {
FILE: ext/nmatrix_atlas/math_atlas.cpp
type nm (line 100) | namespace nm {
type math (line 101) | namespace math {
type atlas (line 102) | namespace atlas {
function lapack_gesvd (line 108) | inline static int lapack_gesvd(char jobu, char jobvt, int m, int n...
function lapack_gesdd (line 116) | inline static int lapack_gesdd(char jobz, int m, int n, void* a, i...
function nm_math_init_atlas (line 131) | void nm_math_init_atlas() {
function VALUE (line 178) | static VALUE nm_atlas_has_clapack(VALUE self) {
function VALUE (line 201) | static VALUE nm_atlas_cblas_scal(VALUE self, VALUE n, VALUE alpha, VALUE...
function VALUE (line 238) | static VALUE nm_atlas_cblas_rotg(VALUE self, VALUE ab) {
function VALUE (line 306) | static VALUE nm_atlas_cblas_rot(VALUE self, VALUE n, VALUE x, VALUE incx...
function VALUE (line 367) | static VALUE nm_atlas_cblas_nrm2(VALUE self, VALUE n, VALUE x, VALUE inc...
function VALUE (line 417) | static VALUE nm_atlas_cblas_asum(VALUE self, VALUE n, VALUE x, VALUE inc...
function VALUE (line 459) | static VALUE nm_atlas_cblas_imax(VALUE self, VALUE n, VALUE x, VALUE inc...
function VALUE (line 491) | static VALUE nm_atlas_cblas_gemv(VALUE self,
function VALUE (line 533) | static VALUE nm_atlas_cblas_gemm(VALUE self,
function VALUE (line 558) | static VALUE nm_atlas_cblas_trsm(VALUE self,
function VALUE (line 592) | static VALUE nm_atlas_cblas_trmm(VALUE self,
function VALUE (line 627) | static VALUE nm_atlas_cblas_syrk(VALUE self,
function VALUE (line 663) | static VALUE nm_atlas_cblas_herk(VALUE self,
function VALUE (line 703) | static VALUE nm_atlas_lapack_gesvd(VALUE self, VALUE jobu, VALUE jobvt, ...
function VALUE (line 763) | static VALUE nm_atlas_lapack_gesdd(VALUE self, VALUE jobz, VALUE m, VALU...
function VALUE (line 830) | static VALUE nm_atlas_lapack_geev(VALUE self, VALUE compute_left, VALUE ...
function VALUE (line 919) | static VALUE nm_atlas_clapack_getrf(VALUE self, VALUE order, VALUE m, VA...
function VALUE (line 965) | static VALUE nm_atlas_clapack_potrf(VALUE self, VALUE order, VALUE uplo,...
function VALUE (line 999) | static VALUE nm_atlas_clapack_getrs(VALUE self, VALUE order, VALUE trans...
function VALUE (line 1043) | static VALUE nm_atlas_clapack_potrs(VALUE self, VALUE order, VALUE uplo,...
function VALUE (line 1082) | static VALUE nm_atlas_clapack_getri(VALUE self, VALUE order, VALUE n, VA...
function VALUE (line 1132) | static VALUE nm_atlas_clapack_potri(VALUE self, VALUE order, VALUE uplo,...
function VALUE (line 1169) | static VALUE nm_atlas_clapack_laswp(VALUE self, VALUE n, VALUE a, VALUE ...
FILE: ext/nmatrix_atlas/math_atlas/cblas_templates_atlas.h
function namespace (line 44) | namespace nm { namespace math { namespace atlas {
FILE: ext/nmatrix_atlas/math_atlas/clapack_templates.h
function namespace (line 37) | namespace nm { namespace math { namespace atlas {
FILE: ext/nmatrix_atlas/math_atlas/geev.h
function namespace (line 39) | namespace nm { namespace math { namespace atlas {
FILE: ext/nmatrix_atlas/math_atlas/gesdd.h
function namespace (line 41) | namespace nm {
FILE: ext/nmatrix_atlas/math_atlas/gesvd.h
function namespace (line 40) | namespace nm {
FILE: ext/nmatrix_atlas/nmatrix_atlas.cpp
function Init_nmatrix_atlas (line 40) | void Init_nmatrix_atlas() {
FILE: ext/nmatrix_fftw/nmatrix_fftw.cpp
type fftw_data (line 50) | struct fftw_data {
function nm_fftw_cleanup (line 58) | static void nm_fftw_cleanup(fftw_data* d)
function nm_fftw_interpret_real_real_kind (line 85) | static void
function nm_fftw_actually_create_plan (line 98) | static void nm_fftw_actually_create_plan(fftw_data* data,
function VALUE (line 152) | static VALUE nm_fftw_create_plan(VALUE self, VALUE rb_shape, VALUE rb_size,
function nm_fftw_actually_set (line 170) | static void nm_fftw_actually_set(VALUE nmatrix, VALUE plan_data)
function VALUE (line 191) | static VALUE nm_fftw_set_input(VALUE self, VALUE nmatrix, VALUE plan_data,
function nm_fftw_actually_execute (line 214) | static void nm_fftw_actually_execute(VALUE nmatrix, VALUE plan_data)
function VALUE (line 238) | static VALUE nm_fftw_execute(VALUE self, VALUE nmatrix, VALUE plan_data,...
function Init_nmatrix_fftw (line 258) | void Init_nmatrix_fftw()
FILE: ext/nmatrix_java/nmatrix/math/MathHelper.java
class MathHelper (line 5) | public class MathHelper{
method log (line 7) | public static double[] log(double base, double[] arr){
method erf (line 15) | public static double[] erf(double[] arr){
method erfc (line 23) | public static double[] erfc(double[] arr){
method gamma (line 31) | public static double[] gamma(double[] arr){
method round (line 39) | public static double[] round(double[] arr){
method ldexp (line 47) | public static double[] ldexp(double[] arr1, double[] arr){
method ldexpScalar (line 55) | public static double[] ldexpScalar(double val, double[] arr){
method ldexpScalar2 (line 63) | public static double[] ldexpScalar2(double val, double[] arr){
method hypot (line 71) | public static double[] hypot(double[] arr1, double[] arr2){
method hypotScalar (line 79) | public static double[] hypotScalar(double val, double[] arr){
method atan2 (line 87) | public static double[] atan2(double[] arr1, double[] arr2){
method atan2Scalar (line 95) | public static double[] atan2Scalar(double val, double[] arr){
method atan2Scalar2 (line 103) | public static double[] atan2Scalar2(double val, double[] arr){
FILE: ext/nmatrix_java/nmatrix/storage/dense/ArrayComparator.java
class ArrayComparator (line 1) | public class ArrayComparator{
method equals (line 3) | public static boolean equals(double[] arr1, double[] arr2){
FILE: ext/nmatrix_java/nmatrix/util/ArrayGenerator.java
class ArrayGenerator (line 1) | public class ArrayGenerator{
method getArrayDouble (line 4) | public static double[] getArrayDouble(double[][] matrix, int row, int ...
method getArrayFloat (line 17) | public static float[] getArrayFloat(float[][] matrix, int row, int col)
method getArrayColMajorDouble (line 30) | public static double[] getArrayColMajorDouble(double[][] matrix, int c...
method getArrayColMajorFloat (line 43) | public static float[] getArrayColMajorFloat(float[][] matrix, int col,...
method getArrayFloatFromDouble (line 56) | public static float[] getArrayFloatFromDouble(double[][] matrix, int r...
method convertArrayFloatFromDouble (line 75) | public static float[] convertArrayFloatFromDouble(double[] array){
FILE: ext/nmatrix_java/nmatrix/util/MatrixGenerator.java
class MatrixGenerator (line 1) | public class MatrixGenerator
method getMatrixFloat (line 5) | public static float[][] getMatrixFloat(float[] array, int row, int col)
method getMatrixDouble (line 19) | public static double[][] getMatrixDouble(double[] array, int row, int ...
method getMatrixColMajorFloat (line 33) | public static float[][] getMatrixColMajorFloat(float[] array, int col,...
FILE: ext/nmatrix_java/nmatrix/util/WrapperType.java
class WrapperType (line 5) | public class WrapperType
method isWrapperType (line 16) | public static boolean isWrapperType(Class<?> clazz)
method getWrapperTypes (line 21) | private static Set<Class<?>> getWrapperTypes()
FILE: ext/nmatrix_java/test/AssertTests.java
class AssertTests (line 26) | public class AssertTests {
method testNMatrixdtypeEquals (line 28) | @Test
method testAssertArrayEquals (line 32) | @Test
method testAssertEquals (line 39) | @Test
method testAssertFalse (line 44) | @Test
method testAssertNotNull (line 49) | @Test
method testAssertNotSame (line 54) | @Test
method testAssertNull (line 59) | @Test
method testAssertSame (line 64) | @Test
method testAssertThatBothContainsString (line 71) | @Test
method testAssertThatHasItems (line 76) | @Test
method testAssertThatEveryItemContainsString (line 81) | @Test
method testAssertThatHamcrestCoreMatchers (line 87) | @Test
method testAssertTrue (line 96) | @Test
FILE: ext/nmatrix_java/test/TestRunner.java
class TestRunner (line 1) | public class TestRunner{
method main (line 2) | public static void main(String[] args) {
FILE: ext/nmatrix_lapacke/lapacke/include/lapacke.h
type lapack_logical (line 129) | typedef lapack_logical (*LAPACK_S_SELECT2) ( const float*, const float* );
type lapack_logical (line 130) | typedef lapack_logical (*LAPACK_S_SELECT3)
type lapack_logical (line 132) | typedef lapack_logical (*LAPACK_D_SELECT2) ( const double*, const double...
type lapack_logical (line 133) | typedef lapack_logical (*LAPACK_D_SELECT3)
type lapack_logical (line 136) | typedef lapack_logical (*LAPACK_C_SELECT1) ( const lapack_complex_float* );
type lapack_logical (line 137) | typedef lapack_logical (*LAPACK_C_SELECT2)
type lapack_logical (line 139) | typedef lapack_logical (*LAPACK_Z_SELECT1) ( const lapack_complex_double...
type lapack_logical (line 140) | typedef lapack_logical (*LAPACK_Z_SELECT2)
FILE: ext/nmatrix_lapacke/lapacke/include/lapacke_config.h
type _lapack_complex_float (line 62) | typedef struct { float real, imag; } _lapack_complex_float;
type _lapack_complex_double (line 63) | typedef struct { double real, imag; } _lapack_complex_double;
FILE: ext/nmatrix_lapacke/lapacke/src/lapacke_cgeev.c
function lapack_int (line 36) | lapack_int LAPACKE_cgeev( int matrix_order, char jobvl, char jobvr,
FILE: ext/nmatrix_lapacke/lapacke/src/lapacke_cgeev_work.c
function lapack_int (line 36) | lapack_int LAPACKE_cgeev_work( int matrix_order, char jobvl, char jobvr,
FILE: ext/nmatrix_lapacke/lapacke/src/lapacke_cgeqrf.c
function lapack_int (line 36) | lapack_int LAPACKE_cgeqrf( int matrix_layout, lapack_int m, lapack_int n,
FILE: ext/nmatrix_lapacke/lapacke/src/lapacke_cgeqrf_work.c
function lapack_int (line 36) | lapack_int LAPACKE_cgeqrf_work( int matrix_layout, lapack_int m, lapack_...
FILE: ext/nmatrix_lapacke/lapacke/src/lapacke_cgesdd.c
function lapack_int (line 36) | lapack_int LAPACKE_cgesdd( int matrix_order, char jobz, lapack_int m,
FILE: ext/nmatrix_lapacke/lapacke/src/lapacke_cgesdd_work.c
function lapack_int (line 36) | lapack_int LAPACKE_cgesdd_work( int matrix_order, char jobz, lapack_int m,
FILE: ext/nmatrix_lapacke/lapacke/src/lapacke_cgesvd.c
function lapack_int (line 36) | lapack_int LAPACKE_cgesvd( int matrix_order, char jobu, char jobvt,
FILE: ext/nmatrix_lapacke/lapacke/src/lapacke_cgesvd_work.c
function lapack_int (line 36) | lapack_int LAPACKE_cgesvd_work( int matrix_order, char jobu, char jobvt,
FILE: ext/nmatrix_lapacke/lapacke/src/lapacke_cgetrf.c
function lapack_int (line 36) | lapack_int LAPACKE_cgetrf( int matrix_order, lapack_int m, lapack_int n,
FILE: ext/nmatrix_lapacke/lapacke/src/lapacke_cgetrf_work.c
function lapack_int (line 36) | lapack_int LAPACKE_cgetrf_work( int matrix_order, lapack_int m, lapack_i...
FILE: ext/nmatrix_lapacke/lapacke/src/lapacke_cgetri.c
function lapack_int (line 36) | lapack_int LAPACKE_cgetri( int matrix_order, lapack_int n,
FILE: ext/nmatrix_lapacke/lapacke/src/lapacke_cgetri_work.c
function lapack_int (line 36) | lapack_int LAPACKE_cgetri_work( int matrix_order, lapack_int n,
FILE: ext/nmatrix_lapacke/lapacke/src/lapacke_cgetrs.c
function lapack_int (line 36) | lapack_int LAPACKE_cgetrs( int matrix_order, char trans, lapack_int n,
FILE: ext/nmatrix_lapacke/lapacke/src/lapacke_cgetrs_work.c
function lapack_int (line 36) | lapack_int LAPACKE_cgetrs_work( int matrix_order, char trans, lapack_int n,
FILE: ext/nmatrix_lapacke/lapacke/src/lapacke_cpotrf.c
function lapack_int (line 36) | lapack_int LAPACKE_cpotrf( int matrix_order, char uplo, lapack_int n,
FILE: ext/nmatrix_lapacke/lapacke/src/lapacke_cpotrf_work.c
function lapack_int (line 36) | lapack_int LAPACKE_cpotrf_work( int matrix_order, char uplo, lapack_int n,
FILE: ext/nmatrix_lapacke/lapacke/src/lapacke_cpotri.c
function lapack_int (line 36) | lapack_int LAPACKE_cpotri( int matrix_order, char uplo, lapack_int n,
FILE: ext/nmatrix_lapacke/lapacke/src/lapacke_cpotri_work.c
function lapack_int (line 36) | lapack_int LAPACKE_cpotri_work( int matrix_order, char uplo, lapack_int n,
FILE: ext/nmatrix_lapacke/lapacke/src/lapacke_cpotrs.c
function lapack_int (line 36) | lapack_int LAPACKE_cpotrs( int matrix_order, char uplo, lapack_int n,
FILE: ext/nmatrix_lapacke/lapacke/src/lapacke_cpotrs_work.c
function lapack_int (line 36) | lapack_int LAPACKE_cpotrs_work( int matrix_order, char uplo, lapack_int n,
FILE: ext/nmatrix_lapacke/lapacke/src/lapacke_cunmqr.c
function lapack_int (line 36) | lapack_int LAPACKE_cunmqr( int matrix_layout, char side, char trans,
FILE: ext/nmatrix_lapacke/lapacke/src/lapacke_cunmqr_work.c
function lapack_int (line 36) | lapack_int LAPACKE_cunmqr_work( int matrix_layout, char side, char trans,
FILE: ext/nmatrix_lapacke/lapacke/src/lapacke_dgeev.c
function lapack_int (line 36) | lapack_int LAPACKE_dgeev( int matrix_order, char jobvl, char jobvr,
FILE: ext/nmatrix_lapacke/lapacke/src/lapacke_dgeev_work.c
function lapack_int (line 36) | lapack_int LAPACKE_dgeev_work( int matrix_order, char jobvl, char jobvr,
FILE: ext/nmatrix_lapacke/lapacke/src/lapacke_dgeqrf.c
function lapack_int (line 36) | lapack_int LAPACKE_dgeqrf( int matrix_layout, lapack_int m, lapack_int n,
FILE: ext/nmatrix_lapacke/lapacke/src/lapacke_dgeqrf_work.c
function lapack_int (line 36) | lapack_int LAPACKE_dgeqrf_work( int matrix_layout, lapack_int m, lapack_...
FILE: ext/nmatrix_lapacke/lapacke/src/lapacke_dgesdd.c
function lapack_int (line 36) | lapack_int LAPACKE_dgesdd( int matrix_order, char jobz, lapack_int m,
FILE: ext/nmatrix_lapacke/lapacke/src/lapacke_dgesdd_work.c
function lapack_int (line 36) | lapack_int LAPACKE_dgesdd_work( int matrix_order, char jobz, lapack_int m,
FILE: ext/nmatrix_lapacke/lapacke/src/lapacke_dgesvd.c
function lapack_int (line 36) | lapack_int LAPACKE_dgesvd( int matrix_order, char jobu, char jobvt,
FILE: ext/nmatrix_lapacke/lapacke/src/lapacke_dgesvd_work.c
function lapack_int (line 36) | lapack_int LAPACKE_dgesvd_work( int matrix_order, char jobu, char jobvt,
FILE: ext/nmatrix_lapacke/lapacke/src/lapacke_dgetrf.c
function lapack_int (line 36) | lapack_int LAPACKE_dgetrf( int matrix_order, lapack_int m, lapack_int n,
FILE: ext/nmatrix_lapacke/lapacke/src/lapacke_dgetrf_work.c
function lapack_int (line 36) | lapack_int LAPACKE_dgetrf_work( int matrix_order, lapack_int m, lapack_i...
FILE: ext/nmatrix_lapacke/lapacke/src/lapacke_dgetri.c
function lapack_int (line 36) | lapack_int LAPACKE_dgetri( int matrix_order, lapack_int n, double* a,
FILE: ext/nmatrix_lapacke/lapacke/src/lapacke_dgetri_work.c
function lapack_int (line 36) | lapack_int LAPACKE_dgetri_work( int matrix_order, lapack_int n, double* a,
FILE: ext/nmatrix_lapacke/lapacke/src/lapacke_dgetrs.c
function lapack_int (line 36) | lapack_int LAPACKE_dgetrs( int matrix_order, char trans, lapack_int n,
FILE: ext/nmatrix_lapacke/lapacke/src/lapacke_dgetrs_work.c
function lapack_int (line 36) | lapack_int LAPACKE_dgetrs_work( int matrix_order, char trans, lapack_int n,
FILE: ext/nmatrix_lapacke/lapacke/src/lapacke_dormqr.c
function lapack_int (line 36) | lapack_int LAPACKE_dormqr( int matrix_layout, char side, char trans,
FILE: ext/nmatrix_lapacke/lapacke/src/lapacke_dormqr_work.c
function lapack_int (line 36) | lapack_int LAPACKE_dormqr_work( int matrix_layout, char side, char trans,
FILE: ext/nmatrix_lapacke/lapacke/src/lapacke_dpotrf.c
function lapack_int (line 36) | lapack_int LAPACKE_dpotrf( int matrix_order, char uplo, lapack_int n, do...
FILE: ext/nmatrix_lapacke/lapacke/src/lapacke_dpotrf_work.c
function lapack_int (line 36) | lapack_int LAPACKE_dpotrf_work( int matrix_order, char uplo, lapack_int n,
FILE: ext/nmatrix_lapacke/lapacke/src/lapacke_dpotri.c
function lapack_int (line 36) | lapack_int LAPACKE_dpotri( int matrix_order, char uplo, lapack_int n, do...
FILE: ext/nmatrix_lapacke/lapacke/src/lapacke_dpotri_work.c
function lapack_int (line 36) | lapack_int LAPACKE_dpotri_work( int matrix_order, char uplo, lapack_int n,
FILE: ext/nmatrix_lapacke/lapacke/src/lapacke_dpotrs.c
function lapack_int (line 36) | lapack_int LAPACKE_dpotrs( int matrix_order, char uplo, lapack_int n,
FILE: ext/nmatrix_lapacke/lapacke/src/lapacke_dpotrs_work.c
function lapack_int (line 36) | lapack_int LAPACKE_dpotrs_work( int matrix_order, char uplo, lapack_int n,
FILE: ext/nmatrix_lapacke/lapacke/src/lapacke_sgeev.c
function lapack_int (line 36) | lapack_int LAPACKE_sgeev( int matrix_order, char jobvl, char jobvr,
FILE: ext/nmatrix_lapacke/lapacke/src/lapacke_sgeev_work.c
function lapack_int (line 36) | lapack_int LAPACKE_sgeev_work( int matrix_order, char jobvl, char jobvr,
FILE: ext/nmatrix_lapacke/lapacke/src/lapacke_sgeqrf.c
function lapack_int (line 36) | lapack_int LAPACKE_sgeqrf( int matrix_layout, lapack_int m, lapack_int n,
FILE: ext/nmatrix_lapacke/lapacke/src/lapacke_sgeqrf_work.c
function lapack_int (line 36) | lapack_int LAPACKE_sgeqrf_work( int matrix_layout, lapack_int m, lapack_...
FILE: ext/nmatrix_lapacke/lapacke/src/lapacke_sgesdd.c
function lapack_int (line 36) | lapack_int LAPACKE_sgesdd( int matrix_order, char jobz, lapack_int m,
FILE: ext/nmatrix_lapacke/lapacke/src/lapacke_sgesdd_work.c
function lapack_int (line 36) | lapack_int LAPACKE_sgesdd_work( int matrix_order, char jobz, lapack_int m,
FILE: ext/nmatrix_lapacke/lapacke/src/lapacke_sgesvd.c
function lapack_int (line 36) | lapack_int LAPACKE_sgesvd( int matrix_order, char jobu, char jobvt,
FILE: ext/nmatrix_lapacke/lapacke/src/lapacke_sgesvd_work.c
function lapack_int (line 36) | lapack_int LAPACKE_sgesvd_work( int matrix_order, char jobu, char jobvt,
FILE: ext/nmatrix_lapacke/lapacke/src/lapacke_sgetrf.c
function lapack_int (line 36) | lapack_int LAPACKE_sgetrf( int matrix_order, lapack_int m, lapack_int n,
FILE: ext/nmatrix_lapacke/lapacke/src/lapacke_sgetrf_work.c
function lapack_int (line 36) | lapack_int LAPACKE_sgetrf_work( int matrix_order, lapack_int m, lapack_i...
FILE: ext/nmatrix_lapacke/lapacke/src/lapacke_sgetri.c
function lapack_int (line 36) | lapack_int LAPACKE_sgetri( int matrix_order, lapack_int n, float* a,
FILE: ext/nmatrix_lapacke/lapacke/src/lapacke_sgetri_work.c
function lapack_int (line 36) | lapack_int LAPACKE_sgetri_work( int matrix_order, lapack_int n, float* a,
FILE: ext/nmatrix_lapacke/lapacke/src/lapacke_sgetrs.c
function lapack_int (line 36) | lapack_int LAPACKE_sgetrs( int matrix_order, char trans, lapack_int n,
FILE: ext/nmatrix_lapacke/lapacke/src/lapacke_sgetrs_work.c
function lapack_int (line 36) | lapack_int LAPACKE_sgetrs_work( int matrix_order, char trans, lapack_int n,
FILE: ext/nmatrix_lapacke/lapacke/src/lapacke_sormqr.c
function lapack_int (line 36) | lapack_int LAPACKE_sormqr( int matrix_layout, char side, char trans,
FILE: ext/nmatrix_lapacke/lapacke/src/lapacke_sormqr_work.c
function lapack_int (line 36) | lapack_int LAPACKE_sormqr_work( int matrix_layout, char side, char trans,
FILE: ext/nmatrix_lapacke/lapacke/src/lapacke_spotrf.c
function lapack_int (line 36) | lapack_int LAPACKE_spotrf( int matrix_order, char uplo, lapack_int n, fl...
FILE: ext/nmatrix_lapacke/lapacke/src/lapacke_spotrf_work.c
function lapack_int (line 36) | lapack_int LAPACKE_spotrf_work( int matrix_order, char uplo, lapack_int n,
FILE: ext/nmatrix_lapacke/lapacke/src/lapacke_spotri.c
function lapack_int (line 36) | lapack_int LAPACKE_spotri( int matrix_order, char uplo, lapack_int n, fl...
FILE: ext/nmatrix_lapacke/lapacke/src/lapacke_spotri_work.c
function lapack_int (line 36) | lapack_int LAPACKE_spotri_work( int matrix_order, char uplo, lapack_int n,
FILE: ext/nmatrix_lapacke/lapacke/src/lapacke_spotrs.c
function lapack_int (line 36) | lapack_int LAPACKE_spotrs( int matrix_order, char uplo, lapack_int n,
FILE: ext/nmatrix_lapacke/lapacke/src/lapacke_spotrs_work.c
function lapack_int (line 36) | lapack_int LAPACKE_spotrs_work( int matrix_order, char uplo, lapack_int n,
FILE: ext/nmatrix_lapacke/lapacke/src/lapacke_zgeev.c
function lapack_int (line 36) | lapack_int LAPACKE_zgeev( int matrix_order, char jobvl, char jobvr,
FILE: ext/nmatrix_lapacke/lapacke/src/lapacke_zgeev_work.c
function lapack_int (line 36) | lapack_int LAPACKE_zgeev_work( int matrix_order, char jobvl, char jobvr,
FILE: ext/nmatrix_lapacke/lapacke/src/lapacke_zgeqrf.c
function lapack_int (line 36) | lapack_int LAPACKE_zgeqrf( int matrix_layout, lapack_int m, lapack_int n,
FILE: ext/nmatrix_lapacke/lapacke/src/lapacke_zgeqrf_work.c
function lapack_int (line 36) | lapack_int LAPACKE_zgeqrf_work( int matrix_layout, lapack_int m, lapack_...
FILE: ext/nmatrix_lapacke/lapacke/src/lapacke_zgesdd.c
function lapack_int (line 36) | lapack_int LAPACKE_zgesdd( int matrix_order, char jobz, lapack_int m,
FILE: ext/nmatrix_lapacke/lapacke/src/lapacke_zgesdd_work.c
function lapack_int (line 36) | lapack_int LAPACKE_zgesdd_work( int matrix_order, char jobz, lapack_int m,
FILE: ext/nmatrix_lapacke/lapacke/src/lapacke_zgesvd.c
function lapack_int (line 36) | lapack_int LAPACKE_zgesvd( int matrix_order, char jobu, char jobvt,
FILE: ext/nmatrix_lapacke/lapacke/src/lapacke_zgesvd_work.c
function lapack_int (line 36) | lapack_int LAPACKE_zgesvd_work( int matrix_order, char jobu, char jobvt,
FILE: ext/nmatrix_lapacke/lapacke/src/lapacke_zgetrf.c
function lapack_int (line 36) | lapack_int LAPACKE_zgetrf( int matrix_order, lapack_int m, lapack_int n,
FILE: ext/nmatrix_lapacke/lapacke/src/lapacke_zgetrf_work.c
function lapack_int (line 36) | lapack_int LAPACKE_zgetrf_work( int matrix_order, lapack_int m, lapack_i...
FILE: ext/nmatrix_lapacke/lapacke/src/lapacke_zgetri.c
function lapack_int (line 36) | lapack_int LAPACKE_zgetri( int matrix_order, lapack_int n,
FILE: ext/nmatrix_lapacke/lapacke/src/lapacke_zgetri_work.c
function lapack_int (line 36) | lapack_int LAPACKE_zgetri_work( int matrix_order, lapack_int n,
FILE: ext/nmatrix_lapacke/lapacke/src/lapacke_zgetrs.c
function lapack_int (line 36) | lapack_int LAPACKE_zgetrs( int matrix_order, char trans, lapack_int n,
FILE: ext/nmatrix_lapacke/lapacke/src/lapacke_zgetrs_work.c
function lapack_int (line 36) | lapack_int LAPACKE_zgetrs_work( int matrix_order, char trans, lapack_int n,
FILE: ext/nmatrix_lapacke/lapacke/src/lapacke_zpotrf.c
function lapack_int (line 36) | lapack_int LAPACKE_zpotrf( int matrix_order, char uplo, lapack_int n,
FILE: ext/nmatrix_lapacke/lapacke/src/lapacke_zpotrf_work.c
function lapack_int (line 36) | lapack_int LAPACKE_zpotrf_work( int matrix_order, char uplo, lapack_int n,
FILE: ext/nmatrix_lapacke/lapacke/src/lapacke_zpotri.c
function lapack_int (line 36) | lapack_int LAPACKE_zpotri( int matrix_order, char uplo, lapack_int n,
FILE: ext/nmatrix_lapacke/lapacke/src/lapacke_zpotri_work.c
function lapack_int (line 36) | lapack_int LAPACKE_zpotri_work( int matrix_order, char uplo, lapack_int n,
FILE: ext/nmatrix_lapacke/lapacke/src/lapacke_zpotrs.c
function lapack_int (line 36) | lapack_int LAPACKE_zpotrs( int matrix_order, char uplo, lapack_int n,
FILE: ext/nmatrix_lapacke/lapacke/src/lapacke_zpotrs_work.c
function lapack_int (line 36) | lapack_int LAPACKE_zpotrs_work( int matrix_order, char uplo, lapack_int n,
FILE: ext/nmatrix_lapacke/lapacke/src/lapacke_zunmqr.c
function lapack_int (line 36) | lapack_int LAPACKE_zunmqr( int matrix_layout, char side, char trans,
FILE: ext/nmatrix_lapacke/lapacke/src/lapacke_zunmqr_work.c
function lapack_int (line 36) | lapack_int LAPACKE_zunmqr_work( int matrix_layout, char side, char trans,
FILE: ext/nmatrix_lapacke/lapacke/utils/lapacke_c_nancheck.c
function lapack_logical (line 37) | lapack_logical LAPACKE_c_nancheck( lapack_int n,
FILE: ext/nmatrix_lapacke/lapacke/utils/lapacke_cge_nancheck.c
function lapack_logical (line 37) | lapack_logical LAPACKE_cge_nancheck( int matrix_order, lapack_int m,
FILE: ext/nmatrix_lapacke/lapacke/utils/lapacke_cge_trans.c
function LAPACKE_cge_trans (line 40) | void LAPACKE_cge_trans( int matrix_order, lapack_int m, lapack_int n,
FILE: ext/nmatrix_lapacke/lapacke/utils/lapacke_cpo_nancheck.c
function lapack_logical (line 37) | lapack_logical LAPACKE_cpo_nancheck( int matrix_order, char uplo,
FILE: ext/nmatrix_lapacke/lapacke/utils/lapacke_cpo_trans.c
function LAPACKE_cpo_trans (line 40) | void LAPACKE_cpo_trans( int matrix_order, char uplo, lapack_int n,
FILE: ext/nmatrix_lapacke/lapacke/utils/lapacke_ctr_nancheck.c
function lapack_logical (line 37) | lapack_logical LAPACKE_ctr_nancheck( int matrix_order, char uplo, char d...
FILE: ext/nmatrix_lapacke/lapacke/utils/lapacke_ctr_trans.c
function LAPACKE_ctr_trans (line 40) | void LAPACKE_ctr_trans( int matrix_order, char uplo, char diag, lapack_i...
FILE: ext/nmatrix_lapacke/lapacke/utils/lapacke_d_nancheck.c
function lapack_logical (line 37) | lapack_logical LAPACKE_d_nancheck( lapack_int n,
FILE: ext/nmatrix_lapacke/lapacke/utils/lapacke_dge_nancheck.c
function lapack_logical (line 37) | lapack_logical LAPACKE_dge_nancheck( int matrix_order, lapack_int m,
FILE: ext/nmatrix_lapacke/lapacke/utils/lapacke_dge_trans.c
function LAPACKE_dge_trans (line 40) | void LAPACKE_dge_trans( int matrix_order, lapack_int m, lapack_int n,
FILE: ext/nmatrix_lapacke/lapacke/utils/lapacke_dpo_nancheck.c
function lapack_logical (line 37) | lapack_logical LAPACKE_dpo_nancheck( int matrix_order, char uplo,
FILE: ext/nmatrix_lapacke/lapacke/utils/lapacke_dpo_trans.c
function LAPACKE_dpo_trans (line 40) | void LAPACKE_dpo_trans( int matrix_order, char uplo, lapack_int n,
FILE: ext/nmatrix_lapacke/lapacke/utils/lapacke_dtr_nancheck.c
function lapack_logical (line 37) | lapack_logical LAPACKE_dtr_nancheck( int matrix_order, char uplo, char d...
FILE: ext/nmatrix_lapacke/lapacke/utils/lapacke_dtr_trans.c
function LAPACKE_dtr_trans (line 40) | void LAPACKE_dtr_trans( int matrix_order, char uplo, char diag, lapack_i...
FILE: ext/nmatrix_lapacke/lapacke/utils/lapacke_lsame.c
function lapack_logical (line 36) | lapack_logical LAPACKE_lsame( char ca, char cb )
FILE: ext/nmatrix_lapacke/lapacke/utils/lapacke_s_nancheck.c
function lapack_logical (line 37) | lapack_logical LAPACKE_s_nancheck( lapack_int n,
FILE: ext/nmatrix_lapacke/lapacke/utils/lapacke_sge_nancheck.c
function lapack_logical (line 37) | lapack_logical LAPACKE_sge_nancheck( int matrix_order, lapack_int m,
FILE: ext/nmatrix_lapacke/lapacke/utils/lapacke_sge_trans.c
function LAPACKE_sge_trans (line 40) | void LAPACKE_sge_trans( int matrix_order, lapack_int m, lapack_int n,
FILE: ext/nmatrix_lapacke/lapacke/utils/lapacke_spo_nancheck.c
function lapack_logical (line 37) | lapack_logical LAPACKE_spo_nancheck( int matrix_order, char uplo,
FILE: ext/nmatrix_lapacke/lapacke/utils/lapacke_spo_trans.c
function LAPACKE_spo_trans (line 40) | void LAPACKE_spo_trans( int matrix_order, char uplo, lapack_int n,
FILE: ext/nmatrix_lapacke/lapacke/utils/lapacke_str_nancheck.c
function lapack_logical (line 37) | lapack_logical LAPACKE_str_nancheck( int matrix_order, char uplo, char d...
FILE: ext/nmatrix_lapacke/lapacke/utils/lapacke_str_trans.c
function LAPACKE_str_trans (line 40) | void LAPACKE_str_trans( int matrix_order, char uplo, char diag, lapack_i...
FILE: ext/nmatrix_lapacke/lapacke/utils/lapacke_xerbla.c
function LAPACKE_xerbla (line 37) | void LAPACKE_xerbla( const char *name, lapack_int info )
FILE: ext/nmatrix_lapacke/lapacke/utils/lapacke_z_nancheck.c
function lapack_logical (line 37) | lapack_logical LAPACKE_z_nancheck( lapack_int n,
FILE: ext/nmatrix_lapacke/lapacke/utils/lapacke_zge_nancheck.c
function lapack_logical (line 37) | lapack_logical LAPACKE_zge_nancheck( int matrix_order, lapack_int m,
FILE: ext/nmatrix_lapacke/lapacke/utils/lapacke_zge_trans.c
function LAPACKE_zge_trans (line 40) | void LAPACKE_zge_trans( int matrix_order, lapack_int m, lapack_int n,
FILE: ext/nmatrix_lapacke/lapacke/utils/lapacke_zpo_nancheck.c
function lapack_logical (line 37) | lapack_logical LAPACKE_zpo_nancheck( int matrix_order, char uplo,
FILE: ext/nmatrix_lapacke/lapacke/utils/lapacke_zpo_trans.c
function LAPACKE_zpo_trans (line 40) | void LAPACKE_zpo_trans( int matrix_order, char uplo, lapack_int n,
FILE: ext/nmatrix_lapacke/lapacke/utils/lapacke_ztr_nancheck.c
function lapack_logical (line 37) | lapack_logical LAPACKE_ztr_nancheck( int matrix_order, char uplo, char d...
FILE: ext/nmatrix_lapacke/lapacke/utils/lapacke_ztr_trans.c
function LAPACKE_ztr_trans (line 40) | void LAPACKE_ztr_trans( int matrix_order, char uplo, char diag, lapack_i...
FILE: ext/nmatrix_lapacke/math_lapacke.cpp
function nm_math_init_lapack (line 96) | void nm_math_init_lapack() {
function VALUE (line 153) | static VALUE nm_lapacke_cblas_scal(VALUE self, VALUE n, VALUE alpha, VAL...
function VALUE (line 190) | static VALUE nm_lapacke_cblas_rotg(VALUE self, VALUE ab) {
function VALUE (line 258) | static VALUE nm_lapacke_cblas_rot(VALUE self, VALUE n, VALUE x, VALUE in...
function VALUE (line 319) | static VALUE nm_lapacke_cblas_nrm2(VALUE self, VALUE n, VALUE x, VALUE i...
function VALUE (line 369) | static VALUE nm_lapacke_cblas_asum(VALUE self, VALUE n, VALUE x, VALUE i...
function VALUE (line 411) | static VALUE nm_lapacke_cblas_imax(VALUE self, VALUE n, VALUE x, VALUE i...
function VALUE (line 443) | static VALUE nm_lapacke_cblas_gemv(VALUE self,
function VALUE (line 485) | static VALUE nm_lapacke_cblas_gemm(VALUE self,
function VALUE (line 510) | static VALUE nm_lapacke_cblas_trsm(VALUE self,
function VALUE (line 544) | static VALUE nm_lapacke_cblas_trmm(VALUE self,
function VALUE (line 579) | static VALUE nm_lapacke_cblas_syrk(VALUE self,
function VALUE (line 615) | static VALUE nm_lapacke_cblas_herk(VALUE self,
function VALUE (line 647) | static VALUE nm_lapacke_lapacke_getri(VALUE self, VALUE order, VALUE n, ...
function VALUE (line 702) | static VALUE nm_lapacke_lapacke_getrf(VALUE self, VALUE order, VALUE m, ...
function VALUE (line 737) | static VALUE nm_lapacke_lapacke_getrs(VALUE self, VALUE order, VALUE tra...
function VALUE (line 776) | static VALUE nm_lapacke_lapacke_potrf(VALUE self, VALUE order, VALUE upl...
function VALUE (line 799) | static VALUE nm_lapacke_lapacke_potrs(VALUE self, VALUE order, VALUE upl...
function VALUE (line 828) | static VALUE nm_lapacke_lapacke_potri(VALUE self, VALUE order, VALUE upl...
function VALUE (line 866) | static VALUE nm_lapacke_lapacke_gesvd(VALUE self, VALUE order, VALUE job...
function VALUE (line 896) | static VALUE nm_lapacke_lapacke_gesdd(VALUE self, VALUE order, VALUE job...
function VALUE (line 940) | static VALUE nm_lapacke_lapacke_geev(VALUE self, VALUE order, VALUE jobv...
function VALUE (line 992) | static VALUE nm_lapacke_lapacke_geqrf(VALUE self, VALUE order, VALUE m, ...
function VALUE (line 1031) | static VALUE nm_lapacke_lapacke_ormqr(VALUE self, VALUE order, VALUE sid...
function VALUE (line 1073) | static VALUE nm_lapacke_lapacke_unmqr(VALUE self, VALUE order, VALUE sid...
FILE: ext/nmatrix_lapacke/math_lapacke/cblas_local.h
type CBLAS_ORDER (line 147) | enum CBLAS_ORDER
type CBLAS_TRANSPOSE (line 148) | enum CBLAS_TRANSPOSE
type CBLAS_ORDER (line 152) | enum CBLAS_ORDER
type CBLAS_TRANSPOSE (line 153) | enum CBLAS_TRANSPOSE
type CBLAS_ORDER (line 157) | enum CBLAS_ORDER
type CBLAS_UPLO (line 157) | enum CBLAS_UPLO
type CBLAS_TRANSPOSE (line 158) | enum CBLAS_TRANSPOSE
type CBLAS_DIAG (line 158) | enum CBLAS_DIAG
type CBLAS_ORDER (line 161) | enum CBLAS_ORDER
type CBLAS_UPLO (line 161) | enum CBLAS_UPLO
type CBLAS_TRANSPOSE (line 162) | enum CBLAS_TRANSPOSE
type CBLAS_DIAG (line 162) | enum CBLAS_DIAG
type CBLAS_ORDER (line 165) | enum CBLAS_ORDER
type CBLAS_UPLO (line 165) | enum CBLAS_UPLO
type CBLAS_TRANSPOSE (line 166) | enum CBLAS_TRANSPOSE
type CBLAS_DIAG (line 166) | enum CBLAS_DIAG
type CBLAS_ORDER (line 168) | enum CBLAS_ORDER
type CBLAS_UPLO (line 168) | enum CBLAS_UPLO
type CBLAS_TRANSPOSE (line 169) | enum CBLAS_TRANSPOSE
type CBLAS_DIAG (line 169) | enum CBLAS_DIAG
type CBLAS_ORDER (line 172) | enum CBLAS_ORDER
type CBLAS_UPLO (line 172) | enum CBLAS_UPLO
type CBLAS_TRANSPOSE (line 173) | enum CBLAS_TRANSPOSE
type CBLAS_DIAG (line 173) | enum CBLAS_DIAG
type CBLAS_ORDER (line 176) | enum CBLAS_ORDER
type CBLAS_UPLO (line 176) | enum CBLAS_UPLO
type CBLAS_TRANSPOSE (line 177) | enum CBLAS_TRANSPOSE
type CBLAS_DIAG (line 177) | enum CBLAS_DIAG
type CBLAS_ORDER (line 180) | enum CBLAS_ORDER
type CBLAS_TRANSPOSE (line 181) | enum CBLAS_TRANSPOSE
type CBLAS_ORDER (line 185) | enum CBLAS_ORDER
type CBLAS_TRANSPOSE (line 186) | enum CBLAS_TRANSPOSE
type CBLAS_ORDER (line 190) | enum CBLAS_ORDER
type CBLAS_UPLO (line 190) | enum CBLAS_UPLO
type CBLAS_TRANSPOSE (line 191) | enum CBLAS_TRANSPOSE
type CBLAS_DIAG (line 191) | enum CBLAS_DIAG
type CBLAS_ORDER (line 194) | enum CBLAS_ORDER
type CBLAS_UPLO (line 194) | enum CBLAS_UPLO
type CBLAS_TRANSPOSE (line 195) | enum CBLAS_TRANSPOSE
type CBLAS_DIAG (line 195) | enum CBLAS_DIAG
type CBLAS_ORDER (line 198) | enum CBLAS_ORDER
type CBLAS_UPLO (line 198) | enum CBLAS_UPLO
type CBLAS_TRANSPOSE (line 199) | enum CBLAS_TRANSPOSE
type CBLAS_DIAG (line 199) | enum CBLAS_DIAG
type CBLAS_ORDER (line 201) | enum CBLAS_ORDER
type CBLAS_UPLO (line 201) | enum CBLAS_UPLO
type CBLAS_TRANSPOSE (line 202) | enum CBLAS_TRANSPOSE
type CBLAS_DIAG (line 202) | enum CBLAS_DIAG
type CBLAS_ORDER (line 205) | enum CBLAS_ORDER
type CBLAS_UPLO (line 205) | enum CBLAS_UPLO
type CBLAS_TRANSPOSE (line 206) | enum CBLAS_TRANSPOSE
type CBLAS_DIAG (line 206) | enum CBLAS_DIAG
type CBLAS_ORDER (line 209) | enum CBLAS_ORDER
type CBLAS_UPLO (line 209) | enum CBLAS_UPLO
type CBLAS_TRANSPOSE (line 210) | enum CBLAS_TRANSPOSE
type CBLAS_DIAG (line 210) | enum CBLAS_DIAG
type CBLAS_ORDER (line 213) | enum CBLAS_ORDER
type CBLAS_TRANSPOSE (line 214) | enum CBLAS_TRANSPOSE
type CBLAS_ORDER (line 218) | enum CBLAS_ORDER
type CBLAS_TRANSPOSE (line 219) | enum CBLAS_TRANSPOSE
type CBLAS_ORDER (line 223) | enum CBLAS_ORDER
type CBLAS_UPLO (line 223) | enum CBLAS_UPLO
type CBLAS_TRANSPOSE (line 224) | enum CBLAS_TRANSPOSE
type CBLAS_DIAG (line 224) | enum CBLAS_DIAG
type CBLAS_ORDER (line 227) | enum CBLAS_ORDER
type CBLAS_UPLO (line 227) | enum CBLAS_UPLO
type CBLAS_TRANSPOSE (line 228) | enum CBLAS_TRANSPOSE
type CBLAS_DIAG (line 228) | enum CBLAS_DIAG
type CBLAS_ORDER (line 231) | enum CBLAS_ORDER
type CBLAS_UPLO (line 231) | enum CBLAS_UPLO
type CBLAS_TRANSPOSE (line 232) | enum CBLAS_TRANSPOSE
type CBLAS_DIAG (line 232) | enum CBLAS_DIAG
type CBLAS_ORDER (line 234) | enum CBLAS_ORDER
type CBLAS_UPLO (line 234) | enum CBLAS_UPLO
type CBLAS_TRANSPOSE (line 235) | enum CBLAS_TRANSPOSE
type CBLAS_DIAG (line 235) | enum CBLAS_DIAG
type CBLAS_ORDER (line 238) | enum CBLAS_ORDER
type CBLAS_UPLO (line 238) | enum CBLAS_UPLO
type CBLAS_TRANSPOSE (line 239) | enum CBLAS_TRANSPOSE
type CBLAS_DIAG (line 239) | enum CBLAS_DIAG
type CBLAS_ORDER (line 242) | enum CBLAS_ORDER
type CBLAS_UPLO (line 242) | enum CBLAS_UPLO
type CBLAS_TRANSPOSE (line 243) | enum CBLAS_TRANSPOSE
type CBLAS_DIAG (line 243) | enum CBLAS_DIAG
type CBLAS_ORDER (line 246) | enum CBLAS_ORDER
type CBLAS_TRANSPOSE (line 247) | enum CBLAS_TRANSPOSE
type CBLAS_ORDER (line 251) | enum CBLAS_ORDER
type CBLAS_TRANSPOSE (line 252) | enum CBLAS_TRANSPOSE
type CBLAS_ORDER (line 256) | enum CBLAS_ORDER
type CBLAS_UPLO (line 256) | enum CBLAS_UPLO
type CBLAS_TRANSPOSE (line 257) | enum CBLAS_TRANSPOSE
type CBLAS_DIAG (line 257) | enum CBLAS_DIAG
type CBLAS_ORDER (line 260) | enum CBLAS_ORDER
type CBLAS_UPLO (line 260) | enum CBLAS_UPLO
type CBLAS_TRANSPOSE (line 261) | enum CBLAS_TRANSPOSE
type CBLAS_DIAG (line 261) | enum CBLAS_DIAG
type CBLAS_ORDER (line 264) | enum CBLAS_ORDER
type CBLAS_UPLO (line 264) | enum CBLAS_UPLO
type CBLAS_TRANSPOSE (line 265) | enum CBLAS_TRANSPOSE
type CBLAS_DIAG (line 265) | enum CBLAS_DIAG
type CBLAS_ORDER (line 267) | enum CBLAS_ORDER
type CBLAS_UPLO (line 267) | enum CBLAS_UPLO
type CBLAS_TRANSPOSE (line 268) | enum CBLAS_TRANSPOSE
type CBLAS_DIAG (line 268) | enum CBLAS_DIAG
type CBLAS_ORDER (line 271) | enum CBLAS_ORDER
type CBLAS_UPLO (line 271) | enum CBLAS_UPLO
type CBLAS_TRANSPOSE (line 272) | enum CBLAS_TRANSPOSE
type CBLAS_DIAG (line 272) | enum CBLAS_DIAG
type CBLAS_ORDER (line 275) | enum CBLAS_ORDER
type CBLAS_UPLO (line 275) | enum CBLAS_UPLO
type CBLAS_TRANSPOSE (line 276) | enum CBLAS_TRANSPOSE
type CBLAS_DIAG (line 276) | enum CBLAS_DIAG
type CBLAS_ORDER (line 283) | enum CBLAS_ORDER
type CBLAS_UPLO (line 283) | enum CBLAS_UPLO
type CBLAS_ORDER (line 287) | enum CBLAS_ORDER
type CBLAS_UPLO (line 287) | enum CBLAS_UPLO
type CBLAS_ORDER (line 291) | enum CBLAS_ORDER
type CBLAS_UPLO (line 291) | enum CBLAS_UPLO
type CBLAS_ORDER (line 295) | enum CBLAS_ORDER
type CBLAS_ORDER (line 298) | enum CBLAS_ORDER
type CBLAS_UPLO (line 298) | enum CBLAS_UPLO
type CBLAS_ORDER (line 301) | enum CBLAS_ORDER
type CBLAS_UPLO (line 301) | enum CBLAS_UPLO
type CBLAS_ORDER (line 304) | enum CBLAS_ORDER
type CBLAS_UPLO (line 304) | enum CBLAS_UPLO
type CBLAS_ORDER (line 308) | enum CBLAS_ORDER
type CBLAS_UPLO (line 308) | enum CBLAS_UPLO
type CBLAS_ORDER (line 312) | enum CBLAS_ORDER
type CBLAS_UPLO (line 312) | enum CBLAS_UPLO
type CBLAS_ORDER (line 316) | enum CBLAS_ORDER
type CBLAS_UPLO (line 316) | enum CBLAS_UPLO
type CBLAS_ORDER (line 320) | enum CBLAS_ORDER
type CBLAS_UPLO (line 320) | enum CBLAS_UPLO
type CBLAS_ORDER (line 324) | enum CBLAS_ORDER
type CBLAS_ORDER (line 327) | enum CBLAS_ORDER
type CBLAS_UPLO (line 327) | enum CBLAS_UPLO
type CBLAS_ORDER (line 330) | enum CBLAS_ORDER
type CBLAS_UPLO (line 330) | enum CBLAS_UPLO
type CBLAS_ORDER (line 333) | enum CBLAS_ORDER
type CBLAS_UPLO (line 333) | enum CBLAS_UPLO
type CBLAS_ORDER (line 337) | enum CBLAS_ORDER
type CBLAS_UPLO (line 337) | enum CBLAS_UPLO
type CBLAS_ORDER (line 345) | enum CBLAS_ORDER
type CBLAS_UPLO (line 345) | enum CBLAS_UPLO
type CBLAS_ORDER (line 349) | enum CBLAS_ORDER
type CBLAS_UPLO (line 349) | enum CBLAS_UPLO
type CBLAS_ORDER (line 353) | enum CBLAS_ORDER
type CBLAS_UPLO (line 353) | enum CBLAS_UPLO
type CBLAS_ORDER (line 357) | enum CBLAS_ORDER
type CBLAS_ORDER (line 360) | enum CBLAS_ORDER
type CBLAS_ORDER (line 363) | enum CBLAS_ORDER
type CBLAS_UPLO (line 363) | enum CBLAS_UPLO
type CBLAS_ORDER (line 366) | enum CBLAS_ORDER
type CBLAS_UPLO (line 366) | enum CBLAS_UPLO
type CBLAS_ORDER (line 369) | enum CBLAS_ORDER
type CBLAS_UPLO (line 369) | enum CBLAS_UPLO
type CBLAS_ORDER (line 372) | enum CBLAS_ORDER
type CBLAS_UPLO (line 372) | enum CBLAS_UPLO
type CBLAS_ORDER (line 376) | enum CBLAS_ORDER
type CBLAS_UPLO (line 376) | enum CBLAS_UPLO
type CBLAS_ORDER (line 380) | enum CBLAS_ORDER
type CBLAS_UPLO (line 380) | enum CBLAS_UPLO
type CBLAS_ORDER (line 384) | enum CBLAS_ORDER
type CBLAS_UPLO (line 384) | enum CBLAS_UPLO
type CBLAS_ORDER (line 388) | enum CBLAS_ORDER
type CBLAS_ORDER (line 391) | enum CBLAS_ORDER
type CBLAS_ORDER (line 394) | enum CBLAS_ORDER
type CBLAS_UPLO (line 394) | enum CBLAS_UPLO
type CBLAS_ORDER (line 397) | enum CBLAS_ORDER
type CBLAS_UPLO (line 397) | enum CBLAS_UPLO
type CBLAS_ORDER (line 400) | enum CBLAS_ORDER
type CBLAS_UPLO (line 400) | enum CBLAS_UPLO
type CBLAS_ORDER (line 403) | enum CBLAS_ORDER
type CBLAS_UPLO (line 403) | enum CBLAS_UPLO
type CBLAS_ORDER (line 416) | enum CBLAS_ORDER
type CBLAS_TRANSPOSE (line 416) | enum CBLAS_TRANSPOSE
type CBLAS_TRANSPOSE (line 417) | enum CBLAS_TRANSPOSE
type CBLAS_ORDER (line 421) | enum CBLAS_ORDER
type CBLAS_SIDE (line 421) | enum CBLAS_SIDE
type CBLAS_UPLO (line 422) | enum CBLAS_UPLO
type CBLAS_ORDER (line 426) | enum CBLAS_ORDER
type CBLAS_UPLO (line 426) | enum CBLAS_UPLO
type CBLAS_TRANSPOSE (line 427) | enum CBLAS_TRANSPOSE
type CBLAS_ORDER (line 430) | enum CBLAS_ORDER
type CBLAS_UPLO (line 430) | enum CBLAS_UPLO
type CBLAS_TRANSPOSE (line 431) | enum CBLAS_TRANSPOSE
type CBLAS_ORDER (line 435) | enum CBLAS_ORDER
type CBLAS_SIDE (line 435) | enum CBLAS_SIDE
type CBLAS_UPLO (line 436) | enum CBLAS_UPLO
type CBLAS_TRANSPOSE (line 436) | enum CBLAS_TRANSPOSE
type CBLAS_DIAG (line 437) | enum CBLAS_DIAG
type CBLAS_ORDER (line 440) | enum CBLAS_ORDER
type CBLAS_SIDE (line 440) | enum CBLAS_SIDE
type CBLAS_UPLO (line 441) | enum CBLAS_UPLO
type CBLAS_TRANSPOSE (line 441) | enum CBLAS_TRANSPOSE
type CBLAS_DIAG (line 442) | enum CBLAS_DIAG
type CBLAS_ORDER (line 446) | enum CBLAS_ORDER
type CBLAS_TRANSPOSE (line 446) | enum CBLAS_TRANSPOSE
type CBLAS_TRANSPOSE (line 447) | enum CBLAS_TRANSPOSE
type CBLAS_ORDER (line 451) | enum CBLAS_ORDER
type CBLAS_SIDE (line 451) | enum CBLAS_SIDE
type CBLAS_UPLO (line 452) | enum CBLAS_UPLO
type CBLAS_ORDER (line 456) | enum CBLAS_ORDER
type CBLAS_UPLO (line 456) | enum CBLAS_UPLO
type CBLAS_TRANSPOSE (line 457) | enum CBLAS_TRANSPOSE
type CBLAS_ORDER (line 460) | enum CBLAS_ORDER
type CBLAS_UPLO (line 460) | enum CBLAS_UPLO
type CBLAS_TRANSPOSE (line 461) | enum CBLAS_TRANSPOSE
type CBLAS_ORDER (line 465) | enum CBLAS_ORDER
type CBLAS_SIDE (line 465) | enum CBLAS_SIDE
type CBLAS_UPLO (line 466) | enum CBLAS_UPLO
type CBLAS_TRANSPOSE (line 466) | enum CBLAS_TRANSPOSE
type CBLAS_DIAG (line 467) | enum CBLAS_DIAG
type CBLAS_ORDER (line 470) | enum CBLAS_ORDER
type CBLAS_SIDE (line 470) | enum CBLAS_SIDE
type CBLAS_UPLO (line 471) | enum CBLAS_UPLO
type CBLAS_TRANSPOSE (line 471) | enum CBLAS_TRANSPOSE
type CBLAS_DIAG (line 472) | enum CBLAS_DIAG
type CBLAS_ORDER (line 476) | enum CBLAS_ORDER
type CBLAS_TRANSPOSE (line 476) | enum CBLAS_TRANSPOSE
type CBLAS_TRANSPOSE (line 477) | enum CBLAS_TRANSPOSE
type CBLAS_ORDER (line 481) | enum CBLAS_ORDER
type CBLAS_SIDE (line 481) | enum CBLAS_SIDE
type CBLAS_UPLO (line 482) | enum CBLAS_UPLO
type CBLAS_ORDER (line 486) | enum CBLAS_ORDER
type CBLAS_UPLO (line 486) | enum CBLAS_UPLO
type CBLAS_TRANSPOSE (line 487) | enum CBLAS_TRANSPOSE
type CBLAS_ORDER (line 490) | enum CBLAS_ORDER
type CBLAS_UPLO (line 490) | enum CBLAS_UPLO
type CBLAS_TRANSPOSE (line 491) | enum CBLAS_TRANSPOSE
type CBLAS_ORDER (line 495) | enum CBLAS_ORDER
type CBLAS_SIDE (line 495) | enum CBLAS_SIDE
type CBLAS_UPLO (line 496) | enum CBLAS_UPLO
type CBLAS_TRANSPOSE (line 496) | enum CBLAS_TRANSPOSE
type CBLAS_DIAG (line 497) | enum CBLAS_DIAG
type CBLAS_ORDER (line 500) | enum CBLAS_ORDER
type CBLAS_SIDE (line 500) | enum CBLAS_SIDE
type CBLAS_UPLO (line 501) | enum CBLAS_UPLO
type CBLAS_TRANSPOSE (line 501) | enum CBLAS_TRANSPOSE
type CBLAS_DIAG (line 502) | enum CBLAS_DIAG
type CBLAS_ORDER (line 506) | enum CBLAS_ORDER
type CBLAS_TRANSPOSE (line 506) | enum CBLAS_TRANSPOSE
type CBLAS_TRANSPOSE (line 507) | enum CBLAS_TRANSPOSE
type CBLAS_ORDER (line 511) | enum CBLAS_ORDER
type CBLAS_SIDE (line 511) | enum CBLAS_SIDE
type CBLAS_UPLO (line 512) | enum CBLAS_UPLO
type CBLAS_ORDER (line 516) | enum CBLAS_ORDER
type CBLAS_UPLO (line 516) | enum CBLAS_UPLO
type CBLAS_TRANSPOSE (line 517) | enum CBLAS_TRANSPOSE
type CBLAS_ORDER (line 520) | enum CBLAS_ORDER
type CBLAS_UPLO (line 520) | enum CBLAS_UPLO
type CBLAS_TRANSPOSE (line 521) | enum CBLAS_TRANSPOSE
type CBLAS_ORDER (line 525) | enum CBLAS_ORDER
type CBLAS_SIDE (line 525) | enum CBLAS_SIDE
type CBLAS_UPLO (line 526) | enum CBLAS_UPLO
type CBLAS_TRANSPOSE (line 526) | enum CBLAS_TRANSPOSE
type CBLAS_DIAG (line 527) | enum CBLAS_DIAG
type CBLAS_ORDER (line 530) | enum CBLAS_ORDER
type CBLAS_SIDE (line 530) | enum CBLAS_SIDE
type CBLAS_UPLO (line 531) | enum CBLAS_UPLO
type CBLAS_TRANSPOSE (line 531) | enum CBLAS_TRANSPOSE
type CBLAS_DIAG (line 532) | enum CBLAS_DIAG
type CBLAS_ORDER (line 540) | enum CBLAS_ORDER
type CBLAS_SIDE (line 540) | enum CBLAS_SIDE
type CBLAS_UPLO (line 541) | enum CBLAS_UPLO
type CBLAS_ORDER (line 545) | enum CBLAS_ORDER
type CBLAS_UPLO (line 545) | enum CBLAS_UPLO
type CBLAS_TRANSPOSE (line 546) | enum CBLAS_TRANSPOSE
type CBLAS_ORDER (line 549) | enum CBLAS_ORDER
type CBLAS_UPLO (line 549) | enum CBLAS_UPLO
type CBLAS_TRANSPOSE (line 550) | enum CBLAS_TRANSPOSE
type CBLAS_ORDER (line 555) | enum CBLAS_ORDER
type CBLAS_SIDE (line 555) | enum CBLAS_SIDE
type CBLAS_UPLO (line 556) | enum CBLAS_UPLO
type CBLAS_ORDER (line 560) | enum CBLAS_ORDER
type CBLAS_UPLO (line 560) | enum CBLAS_UPLO
type CBLAS_TRANSPOSE (line 561) | enum CBLAS_TRANSPOSE
type CBLAS_ORDER (line 564) | enum CBLAS_ORDER
type CBLAS_UPLO (line 564) | enum CBLAS_UPLO
type CBLAS_TRANSPOSE (line 565) | enum CBLAS_TRANSPOSE
FILE: ext/nmatrix_lapacke/math_lapacke/cblas_templates_lapacke.h
function namespace (line 44) | namespace nm { namespace math { namespace lapacke {
FILE: ext/nmatrix_lapacke/math_lapacke/lapacke_templates.h
function namespace (line 32) | namespace nm { namespace math { namespace lapacke {
type CBLAS_ORDER (line 281) | enum CBLAS_ORDER
function lapacke_potrs (line 288) | int lapacke_potrs(const enum CBLAS_ORDER order, char uplo, const int n, ...
function potri (line 295) | int potri(const enum CBLAS_ORDER order, char uplo, const int n, DType* a...
function potri (line 301) | inline int potri(const enum CBLAS_ORDER order, char uplo, const int n, f...
function potri (line 306) | inline int potri(const enum CBLAS_ORDER order, char uplo, const int n, d...
function potri (line 311) | inline int potri(const enum CBLAS_ORDER order, char uplo, const int n, C...
function potri (line 316) | inline int potri(const enum CBLAS_ORDER order, char uplo, const int n, C...
function lapacke_potri (line 321) | int lapacke_potri(const enum CBLAS_ORDER order, char uplo, const int n, ...
function gesvd (line 327) | int gesvd(int matrix_layout, char jobu, char jobvt, int m, int n, DType*...
function lapacke_gesvd (line 353) | int lapacke_gesvd(int matrix_layout, char jobu, char jobvt, int m, int n...
function gesdd (line 359) | int gesdd(int matrix_layout, char jobz, int m, int n, DType* a, int lda,...
function lapacke_gesdd (line 385) | int lapacke_gesdd(int matrix_layout, char jobz, int m, int n, void* a, i...
function geev (line 400) | int geev(int matrix_layout, char jobvl, char jobvr, int n, DType* a, int...
function geev (line 406) | inline int geev(int matrix_layout, char jobvl, char jobvr, int n, float*...
function geev (line 411) | inline int geev(int matrix_layout, char jobvl, char jobvr, int n, double...
function geev (line 416) | inline int geev(int matrix_layout, char jobvl, char jobvr, int n, Comple...
function geev (line 421) | inline int geev(int matrix_layout, char jobvl, char jobvr, int n, Comple...
function lapacke_geev (line 426) | int lapacke_geev(int matrix_layout, char jobvl, char jobvr, int n, void*...
FILE: ext/nmatrix_lapacke/nmatrix_lapacke.cpp
function Init_nmatrix_lapacke (line 38) | void Init_nmatrix_lapacke() {
FILE: lib/nmatrix/atlas.rb
class NMatrix (line 38) | class NMatrix
type LAPACK (line 42) | module LAPACK
function posv (line 60) | def posv(uplo, a, b)
function geev (line 86) | def geev(matrix, which=:both)
function gesvd (line 171) | def gesvd(matrix, workspace_size=1)
function gesdd (line 187) | def gesdd(matrix, workspace_size=nil)
type BLAS (line 50) | module BLAS
type LAPACK (line 58) | module LAPACK
function posv (line 60) | def posv(uplo, a, b)
function geev (line 86) | def geev(matrix, which=:both)
function gesvd (line 171) | def gesvd(matrix, workspace_size=1)
function gesdd (line 187) | def gesdd(matrix, workspace_size=nil)
method invert! (line 210) | def invert!
method potrf! (line 236) | def potrf!(which)
FILE: lib/nmatrix/blas.rb
type NMatrix::BLAS (line 30) | module NMatrix::BLAS
function gemm (line 75) | def gemm(a, b, c = nil, alpha = 1.0, beta = 0.0,
function gemv (line 157) | def gemv(a, x, y = nil, alpha = 1.0, beta = 0.0,
function rot (line 217) | def rot(x, y, c, s, incx = 1, incy = 1, n = nil, in_place=false)
function rot! (line 251) | def rot!(x, y, c, s, incx = 1, incy = 1, n = nil)
function rotg (line 273) | def rotg(ab)
function asum (line 299) | def asum(x, incx = 1, n = nil)
function nrm2 (line 326) | def nrm2(x, incx = 1, n = nil)
function scal (line 353) | def scal(alpha, vector, incx=1, n=nil)
function cblas_trmm (line 363) | def cblas_trmm(order, side, uplo, trans_a, diag, m, n, alpha, a, lda, ...
function cblas_syrk (line 368) | def cblas_syrk(order, uplo, trans, n, k, alpha, a, lda, beta, c, ldc)
function cblas_herk (line 373) | def cblas_herk(order, uplo, trans, n, k, alpha, a, lda, beta, c, ldc)
FILE: lib/nmatrix/cruby/math.rb
class NMatrix (line 31) | class NMatrix
method getrf! (line 53) | def getrf!
method geqrf! (line 100) | def geqrf!
method ormqr (line 133) | def ormqr(tau, side=:left, transpose=false, c=nil)
method unmqr (line 167) | def unmqr(tau, side=:left, transpose=false, c=nil)
method potrf! (line 195) | def potrf!(which)
method potrf_upper! (line 200) | def potrf_upper!
method potrf_lower! (line 204) | def potrf_lower!
method factorize_cholesky (line 220) | def factorize_cholesky
method factorize_lu (line 240) | def factorize_lu with_permutation_matrix=nil
method factorize_qr (line 268) | def factorize_qr
method solve (line 334) | def solve(b, opts = {})
method least_squares (line 412) | def least_squares(b, tolerance: 10e-6)
method gesvd! (line 461) | def gesvd!(workspace_size=1)
method gesvd (line 475) | def gesvd(workspace_size=1)
method gesdd! (line 492) | def gesdd!(workspace_size=nil)
method gesdd (line 507) | def gesdd(workspace_size=nil)
method laswp! (line 535) | def laswp!(ary, opts={})
method laswp (line 582) | def laswp(ary, opts={})
method det (line 611) | def det
method complex_conjugate (line 653) | def complex_conjugate(new_stype = self.stype)
method conjugate_transpose (line 667) | def conjugate_transpose
method asum (line 680) | def asum incx=1, n=nil
method nrm2 (line 699) | def nrm2 incx=1, n=nil
method scale! (line 717) | def scale!(alpha, incx=1, n=nil)
method scale (line 737) | def scale(alpha, incx=1, n=nil)
FILE: lib/nmatrix/enumerate.rb
class NMatrix (line 29) | class NMatrix
method each (line 40) | def each &bl
method map (line 72) | def map(&bl)
method map! (line 88) | def map!
method each_rank (line 118) | def each_rank(dimen=0, get_by=:reference)
method each_row (line 132) | def each_row(get_by=:reference)
method each_column (line 145) | def each_column(get_by=:reference)
method each_layer (line 161) | def each_layer(get_by=:reference)
method each_stored_with_index (line 176) | def each_stored_with_index(&block)
method inject_rank (line 218) | def inject_rank(dimen=0, initial=nil, dtype=nil)
FILE: lib/nmatrix/fftw.rb
class NMatrix (line 33) | class NMatrix
method fft (line 45) | def fft
method fft2 (line 55) | def fft2
type FFTW (line 64) | module FFTW
class Plan (line 65) | class Plan
method initialize (line 240) | def initialize shape, opts={}
method set_input (line 279) | def set_input ip
method execute (line 301) | def execute
method combine_flags (line 321) | def combine_flags flgs
method verify_opts (line 331) | def verify_opts opts
method encoded_rr_kind (line 338) | def encoded_rr_kind
FILE: lib/nmatrix/homogeneous.rb
class NMatrix (line 31) | class NMatrix
method x_rotation (line 66) | def x_rotation angle_in_radians, opts={}
method y_rotation (line 75) | def y_rotation angle_in_radians, opts={}
method z_rotation (line 84) | def z_rotation angle_in_radians, opts={}
method translation (line 127) | def translation *args
method quaternion (line 159) | def quaternion
method angle_vector (line 228) | def angle_vector
FILE: lib/nmatrix/io/fortran_format.rb
class NMatrix (line 30) | class NMatrix
type IO (line 31) | module IO
type FortranFormat (line 32) | module FortranFormat
class Reader (line 45) | class Reader
method initialize (line 54) | def initialize string
method parse (line 72) | def parse
method parentheses_missing? (line 89) | def parentheses_missing?
method valid_fortran_format? (line 94) | def valid_fortran_format?
method load_result (line 104) | def load_result
method create_integer_hash (line 114) | def create_integer_hash
method create_float_hash (line 120) | def create_float_hash
method create_exp_hash (line 127) | def create_exp_hash
FILE: lib/nmatrix/io/harwell_boeing.rb
class NMatrix (line 34) | class NMatrix
type IO (line 35) | module IO
type HarwellBoeing (line 36) | module HarwellBoeing
function load (line 70) | def load file_path, opts={}
class Reader (line 79) | class Reader
method initialize (line 80) | def initialize file_name
method header (line 89) | def header
method values (line 133) | def values
method read_column_pointers (line 152) | def read_column_pointers
method read_row_indices (line 164) | def read_row_indices
method read_values (line 176) | def read_values
method read_numbers (line 186) | def read_numbers to_dtype, num_of_lines, numbers_per_line, numbe...
method assemble_matrix (line 206) | def assemble_matrix
FILE: lib/nmatrix/io/market.rb
type NMatrix::IO::Market (line 41) | module NMatrix::IO::Market
function load (line 66) | def load(filename)
function save (line 101) | def save(matrix, filename, options = {})
function save_coordinate (line 132) | def save_coordinate matrix, file, symmetry, pattern
function save_array (line 160) | def save_array matrix, file, symmetry
function load_array (line 181) | def load_array file, converter, dtype, entry_type, symmetry
function load_coordinate (line 216) | def load_coordinate file, converter, dtype, entry_type, symmetry
FILE: lib/nmatrix/io/mat5_reader.rb
type NMatrix::IO::Matlab (line 32) | module NMatrix::IO::Matlab
class Mat5Reader (line 35) | class Mat5Reader < MatReader #:nodoc:
class Compressed (line 38) | class Compressed #:nodoc:
method initialize (line 43) | def initialize(stream = nil, byte_order = nil, content_or_bytes = ...
method compressed (line 55) | def compressed
method content (line 61) | def content
method padded_bytes (line 65) | def padded_bytes
method write_packed (line 70) | def write_packed(packedio, options = {})
method read_packed (line 74) | def read_packed(packedio, options)
method extract (line 80) | def extract
class MatrixData (line 98) | class MatrixData < MatrixDataStruct #:nodoc:
method write_packed (line 101) | def write_packed(packedio, options)
method to_ruby (line 121) | def to_ruby
method guess_dtype_from_mdtype (line 136) | def guess_dtype_from_mdtype
method unpacked_data (line 153) | def unpacked_data(real_mdtype = nil, imag_mdtype = nil)
method repacked_data (line 187) | def repacked_data(to_dtype = nil)
method repacked_indices (line 242) | def repacked_indices
method to_nm (line 272) | def to_nm(dtype = nil)
method read_packed (line 297) | def read_packed(packedio, options)
method ignore_padding (line 347) | def ignore_padding(packedio, bytes)
method initialize (line 368) | def initialize(stream, options = {})
method to_a (line 373) | def to_a
method to_ruby (line 379) | def to_ruby
method guess_byte_order (line 389) | def guess_byte_order
method seek_and_read_file_header (line 396) | def seek_and_read_file_header
method each (line 401) | def each(&block)
class Header (line 422) | class Header < Struct.new(:desc, :data_offset, :version, :endian) #:...
method write_packed (line 433) | def write_packed(packedio, options)
method read_packed (line 440) | def read_packed(packedio, options)
class Tag (line 455) | class Tag < Struct.new(:data_type, :raw_data_type, :bytes, :small) #...
method write_packed (line 462) | def write_packed packedio, options
method small? (line 466) | def small?
method size (line 470) | def size
method read_packed (line 474) | def read_packed packedio, options
method inspect (line 496) | def inspect
class ElementDataIOError (line 502) | class ElementDataIOError < IOError #:nodoc:
method initialize (line 505) | def initialize(tag = nil, msg = nil)
method to_s (line 510) | def to_s
class Element (line 516) | class Element < Struct.new(:tag, :data) #:nodoc:
method write_packed (line 519) | def write_packed packedio, options
method read_packed (line 523) | def read_packed(packedio, options)
method ignore_padding (line 564) | def ignore_padding(packedio, bytes)
method to_ruby (line 574) | def to_ruby
class RawElement (line 581) | class RawElement < Element #:nodoc:
method read_packed (line 582) | def read_packed(packedio, options)
FILE: lib/nmatrix/io/mat_reader.rb
type NMatrix::IO::Matlab (line 32) | module NMatrix::IO::Matlab
class MatReader (line 38) | class MatReader #:nodoc:
method initialize (line 167) | def initialize(stream, options = {})
method guess_byte_order (line 177) | def guess_byte_order
FILE: lib/nmatrix/io/point_cloud.rb
type NMatrix::IO::PointCloud (line 38) | module NMatrix::IO::PointCloud
function load (line 52) | def load(filename)
class MetaReader (line 57) | class MetaReader #:nodoc:
method dtype_by_type_and_size (line 77) | def dtype_by_type_and_size t, s
method initialize (line 103) | def initialize filename
method read_entry (line 133) | def read_entry f, entry, assign=nil, convert=nil
method dtype (line 163) | def dtype
method shape (line 182) | def shape
FILE: lib/nmatrix/jruby/decomposition.rb
class NMatrix (line 1) | class NMatrix
method matrix_solve (line 5) | def matrix_solve rhs
FILE: lib/nmatrix/jruby/enumerable.rb
type Enumerable (line 2) | module Enumerable
function sum (line 5) | def sum(identity = 0, &block)
FILE: lib/nmatrix/jruby/math.rb
class NMatrix (line 31) | class NMatrix
method getrf! (line 53) | def getrf!
method geqrf! (line 84) | def geqrf!
method ormqr (line 117) | def ormqr(tau, side=:left, transpose=false, c=nil)
method unmqr (line 151) | def unmqr(tau, side=:left, transpose=false, c=nil)
method potrf! (line 179) | def potrf!(which)
method potrf_upper! (line 195) | def potrf_upper!
method potrf_lower! (line 199) | def potrf_lower!
method factorize_cholesky (line 215) | def factorize_cholesky
method factorize_lu (line 240) | def factorize_lu with_permutation_matrix=nil
method factorize_qr (line 267) | def factorize_qr
method solve (line 327) | def solve(b, opts = {})
method det (line 382) | def det
method complex_conjugate (line 404) | def complex_conjugate(new_stype = self.stype)
method conjugate_transpose (line 418) | def conjugate_transpose
method asum (line 431) | def asum incx=1, n=nil
method nrm2 (line 450) | def nrm2 incx=1, n=nil
method scale! (line 467) | def scale!(alpha, incx=1, n=nil)
method scale (line 488) | def scale(alpha, incx=1, n=nil)
FILE: lib/nmatrix/jruby/nmatrix_java.rb
class NMatrix (line 17) | class NMatrix
method initialize (line 21) | def initialize(*args)
method min_dtype (line 110) | def self.min_dtype(alpha)
method upcast (line 114) | def self.upcast(alpha, beta)
method clone (line 118) | def clone
method entries (line 126) | def entries
method twoDMat (line 130) | def twoDMat
method dtype (line 134) | def dtype
method guess_dtype (line 139) | def self.guess_dtype arg
method stype (line 143) | def stype
method cast_full (line 147) | def cast_full *args
method default_value (line 156) | def default_value
method __list_default_value__ (line 160) | def __list_default_value__
method __yale_default_value__ (line 164) | def __yale_default_value__
method [] (line 168) | def [] *args
method slice (line 172) | def slice(*args)
method []= (line 176) | def []=(*args)
method is_ref? (line 188) | def is_ref?
method effective_dim (line 198) | def effective_dim(s)
method create_dummy_nmatrix (line 212) | def create_dummy_nmatrix
method __list_to_hash__ (line 221) | def __list_to_hash__
method shape (line 227) | def shape
method supershape (line 231) | def supershape s
method offset (line 247) | def offset
method det_exact (line 253) | def det_exact
method det_exact2 (line 273) | def det_exact2
method complex_conjugate! (line 288) | def complex_conjugate!
method count_max_elements (line 295) | def count_max_elements
method reshape_bang (line 299) | def reshape_bang arg
method interpret_shape (line 322) | def interpret_shape(shape_ary, dim)
method each_with_indices (line 347) | def each_with_indices
method each_stored_with_indices (line 376) | def each_stored_with_indices
method map_stored (line 404) | def map_stored
method each_ordered_stored_with_indices (line 408) | def each_ordered_stored_with_indices
method __dense_each__ (line 415) | def __dense_each__
method __dense_map__ (line 441) | def __dense_map__
method __dense_map_pair__ (line 461) | def __dense_map_pair__
method __list_map_merged_stored__ (line 465) | def __list_map_merged_stored__
method __list_map_stored__ (line 469) | def __list_map_stored__
method __yale_map_merged_stored__ (line 473) | def __yale_map_merged_stored__
method __yale_map_stored__ (line 477) | def __yale_map_stored__
method __yale_stored_diagonal_each_with_indices__ (line 481) | def __yale_stored_diagonal_each_with_indices__
method __yale_stored_nondiagonal_each_with_indices__ (line 485) | def __yale_stored_nondiagonal_each_with_indices__
method == (line 492) | def ==(otherNmatrix)
method =~ (line 516) | def =~ (other)
method !~ (line 545) | def !~ (other)
method <= (line 574) | def <= (other)
method >= (line 603) | def >= (other)
method < (line 632) | def < (other)
method > (line 661) | def > (other)
method dot (line 694) | def dot(other)
method symmetric? (line 722) | def symmetric?
method is_symmetric (line 726) | def is_symmetric(hermitian)
method hermitian? (line 748) | def hermitian?
method capacity (line 752) | def capacity
method __inverse__ (line 760) | def __inverse__(matrix, bool =true)
method __inverse__! (line 782) | def __inverse__!
method __inverse_exact__ (line 803) | def __inverse_exact__
method __hessenberg__ (line 830) | def __hessenberg__(param)
FILE: lib/nmatrix/jruby/operators.rb
class NMatrix (line 1) | class NMatrix
method + (line 5) | def +(other)
method - (line 21) | def -(other)
method * (line 37) | def *(other)
method / (line 53) | def /(other)
method ** (line 69) | def ** val
method % (line 77) | def %(other)
method atan2 (line 81) | def atan2(other, scalar=false)
method ldexp (line 95) | def ldexp(other, scalar=false)
method hypot (line 109) | def hypot(other, scalar=false)
method sin (line 123) | def sin
method cos (line 129) | def cos
method tan (line 135) | def tan
method asin (line 141) | def asin
method acos (line 147) | def acos
method atan (line 153) | def atan
method sinh (line 159) | def sinh
method cosh (line 165) | def cosh
method tanh (line 171) | def tanh
method asinh (line 179) | def asinh
method acosh (line 185) | def acosh
method atanh (line 191) | def atanh
method exp (line 197) | def exp
method log (line 203) | def log(val = :natural)
method log2 (line 213) | def log2
method log10 (line 217) | def log10
method sqrt (line 223) | def sqrt
method erf (line 229) | def erf
method erfc (line 235) | def erfc
method cbrt (line 241) | def cbrt
method gamma (line 247) | def gamma
method -@ (line 253) | def -@
method floor (line 259) | def floor
method ceil (line 267) | def ceil
method round (line 275) | def round
FILE: lib/nmatrix/jruby/slice.rb
class NMatrix (line 1) | class NMatrix
method get_slice (line 3) | def get_slice(dim, args, shape_array)
method get_stride (line 59) | def get_stride(nmatrix)
method xslice (line 70) | def xslice(args)
method xslice_ref (line 95) | def xslice_ref(args)
method dense_storage_get (line 118) | def dense_storage_get(slice,stride)
method slice_copy (line 168) | def slice_copy(src, dest,lengths, pdest, psrc,n)
method dense_storage_coords (line 181) | def dense_storage_coords(s, slice_pos, coords_out, stride, offset) #a...
method dense_storage_pos (line 192) | def dense_storage_pos(coords,stride)
method slice_set (line 201) | def slice_set(dest, lengths, pdest, rank, v, v_size, v_offset)
method dense_storage_set (line 221) | def dense_storage_set(slice, right)
FILE: lib/nmatrix/lapack_core.rb
class NMatrix (line 35) | class NMatrix
type LAPACK (line 37) | module LAPACK
function posv (line 61) | def posv(uplo, a, b)
function laswp (line 69) | def laswp(matrix, ipiv)
function alloc_svd_result (line 77) | def alloc_svd_result(matrix)
function gesvd (line 98) | def gesvd(matrix, workspace_size=1)
function gesdd (line 115) | def gesdd(matrix, workspace_size=nil)
function geev (line 145) | def geev(matrix, which=:both)
function lapack_gesvd (line 152) | def lapack_gesvd(jobu, jobvt, m, n, a, lda, s, u, ldu, vt, ldvt, lwork)
function lapack_gesdd (line 156) | def lapack_gesdd(jobz, m, n, a, lda, s, u, ldu, vt, ldvt, lwork)
function lapack_geev (line 160) | def lapack_geev(jobvl, jobvr, n, a, lda, w, wi, vl, ldvl, vr, ldvr, ...
function clapack_potrf (line 164) | def clapack_potrf(order, uplo, n, a, lda)
function clapack_potri (line 168) | def clapack_potri(order, uplo, n, a, lda)
function clapack_potrs (line 172) | def clapack_potrs(order, uplo, n, nrhs, a, lda, b, ldb)
function clapack_getri (line 176) | def clapack_getri(order, n, a, lda, ipiv)
FILE: lib/nmatrix/lapack_ext_common.rb
class NMatrix (line 29) | class NMatrix
method register_lapack_extension (line 30) | def NMatrix.register_lapack_extension(name)
method dot (line 40) | def dot(right_v)
FILE: lib/nmatrix/lapacke.rb
class NMatrix (line 37) | class NMatrix
type LAPACK (line 40) | module LAPACK
function posv (line 58) | def posv(uplo, a, b)
function geev (line 74) | def geev(matrix, which=:both)
function gesvd (line 145) | def gesvd(matrix, workspace_size=1)
function gesdd (line 157) | def gesdd(matrix, workspace_size=nil)
type BLAS (line 48) | module BLAS
type LAPACK (line 56) | module LAPACK
function posv (line 58) | def posv(uplo, a, b)
function geev (line 74) | def geev(matrix, which=:both)
function gesvd (line 145) | def gesvd(matrix, workspace_size=1)
function gesdd (line 157) | def gesdd(matrix, workspace_size=nil)
method getrf! (line 169) | def getrf!
method invert! (line 177) | def invert!
method potrf! (line 191) | def potrf!(which)
method solve (line 198) | def solve(b, opts = {})
method geqrf! (line 262) | def geqrf!
method ormqr (line 299) | def ormqr(tau, side=:left, transpose=false, c=nil)
method unmqr (line 340) | def unmqr(tau, side=:left, transpose=false, c=nil)
FILE: lib/nmatrix/math.rb
class NMatrix (line 31) | class NMatrix
type NMMath (line 33) | module NMMath #:nodoc:
type FactorizeLUMethods (line 40) | module FactorizeLUMethods
function permutation_matrix_from (line 42) | def permutation_matrix_from(pivot_array)
function permutation_array_for (line 51) | def permutation_array_for(pivot_array)
method invert! (line 77) | def invert!
method invert (line 102) | def invert
method exact_inverse! (line 124) | def exact_inverse!
method exact_inverse (line 153) | def exact_inverse
method pinv (line 202) | def pinv(tolerance = 1e-15)
method adjugate! (line 244) | def adjugate!
method adjugate (line 271) | def adjugate
method hessenberg (line 287) | def hessenberg
method hessenberg! (line 292) | def hessenberg!
method matrix_norm (line 327) | def matrix_norm type = 2
method cov (line 355) | def cov(opts={})
method corr (line 368) | def corr
method pow (line 387) | def pow n
method kron_prod (line 432) | def kron_prod(mat)
method trace (line 471) | def trace
method mean (line 490) | def mean(dimen=0)
method sum (line 510) | def sum(dimen=0)
method min (line 526) | def min(dimen=0)
method max (line 545) | def max(dimen=0)
method variance (line 567) | def variance(dimen=0)
method std (line 590) | def std(dimen=0)
method abs_dtype (line 601) | def abs_dtype
method abs (line 617) | def abs
method fro_matrix_norm (line 630) | def fro_matrix_norm
method two_matrix_norm (line 640) | def two_matrix_norm minus = false
method one_matrix_norm (line 651) | def one_matrix_norm minus = false
method inf_matrix_norm (line 665) | def inf_matrix_norm minus = false
method positive_definite? (line 688) | def positive_definite?
method svd_rank (line 713) | def svd_rank(tolerence="default")
method __list_unary_log__ (line 775) | def __list_unary_log__(base)
method __yale_unary_log__ (line 779) | def __yale_unary_log__(base)
method __dense_unary_log__ (line 783) | def __dense_unary_log__(base)
method __list_unary_negate__ (line 788) | def __list_unary_negate__
method __yale_unary_negate__ (line 792) | def __yale_unary_negate__
method __dense_unary_negate__ (line 796) | def __dense_unary_negate__
method __list_unary_round__ (line 802) | def __list_unary_round__(precision)
method __yale_unary_round__ (line 811) | def __yale_unary_round__(precision)
method __dense_unary_round__ (line 820) | def __dense_unary_round__(precision)
method dtype_for_floor_or_ceil (line 830) | def dtype_for_floor_or_ceil
FILE: lib/nmatrix/mkmf.rb
function create_conf_h (line 8) | def create_conf_h(file) #:nodoc:
function find_newer_gplusplus (line 30) | def find_newer_gplusplus #:nodoc:
function gplusplus_version (line 44) | def gplusplus_version
FILE: lib/nmatrix/monkeys.rb
class Array (line 33) | class Array
method to_nm (line 44) | def to_nm(shape = nil, dtype = nil, stype = :dense)
class Object (line 92) | class Object #:nodoc:
method returning (line 93) | def returning(value)
type Math (line 100) | module Math #:nodoc:
class String (line 118) | class String
method underscore (line 119) | def underscore
type AutoloadPatch (line 130) | module AutoloadPatch #:nodoc
function const_missing (line 131) | def const_missing(name)
FILE: lib/nmatrix/nmatrix.rb
function jruby? (line 35) | def jruby?
class NMatrix (line 65) | class NMatrix
type IO (line 67) | module IO
type Matlab (line 74) | module Matlab
function load_mat (line 83) | def load_mat(file_path)
method load_matlab_file (line 99) | def load_matlab_file(file_path)
method load_pcd_file (line 110) | def load_pcd_file(file_path)
method size (line 115) | def size(shape)
method meshgrid (line 147) | def meshgrid(vectors, options = {})
method pretty_print (line 175) | def pretty_print(q) #:nodoc:
method cast (line 239) | def cast(*params)
method rows (line 269) | def rows
method cols (line 280) | def cols
method diagonal (line 294) | def diagonal main_diagonal=true
method to_hash (line 319) | def to_hash
method inspect (line 340) | def inspect #:nodoc:
method __yale_ary__to_s (line 346) | def __yale_ary__to_s(sym) #:nodoc:
method integer_dtype? (line 358) | def integer_dtype?
method float_dtype? (line 367) | def float_dtype?
method complex_dtype? (line 377) | def complex_dtype?
method object_dtype? (line 387) | def object_dtype?
method to_f (line 401) | def to_f
method to_flat_array (line 413) | def to_flat_array
method size (line 426) | def size
method to_s (line 431) | def to_s #:nodoc:
method nvector? (line 442) | def nvector?
method vector? (line 452) | def vector?
method to_a (line 464) | def to_a(dimen=nil)
method rank (line 494) | def rank(shape_idx, rank_idx, meth = :copy)
method column (line 529) | def column(column_number, get_by = :copy)
method row (line 546) | def row(row_number, get_by = :copy)
method last (line 556) | def last
method reshape (line 573) | def reshape new_shape,*shapes
method reshape! (line 598) | def reshape! new_shape,*shapes
method transpose (line 625) | def transpose(permute = nil)
method concat (line 695) | def concat(*matrices)
method hconcat (line 754) | def hconcat(*matrices)
method vconcat (line 759) | def vconcat(*matrices)
method dconcat (line 764) | def dconcat(*matrices)
method upper_triangle (line 782) | def upper_triangle(k = 0)
method upper_triangle! (line 811) | def upper_triangle!(k = 0)
method lower_triangle (line 837) | def lower_triangle(k = 0)
method lower_triangle! (line 866) | def lower_triangle!(k = 0)
method layer (line 890) | def layer(layer_number, get_by = :copy)
method shuffle! (line 915) | def shuffle!(*args)
method shuffle (line 933) | def shuffle(*args)
method sorted_indices (line 946) | def sorted_indices
method binned_sorted_indices (line 960) | def binned_sorted_indices
method method_missing (line 977) | def method_missing name, *args, &block #:nodoc:
method respond_to? (line 988) | def respond_to?(method, include_all = false) #:nodoc:
method inject (line 1005) | def inject(sym)
method index (line 1013) | def index(value)
method clone_structure (line 1036) | def clone_structure(capacity = nil)
method repeat (line 1055) | def repeat(count, axis)
method inspect_helper (line 1075) | def inspect_helper #:nodoc:
method reshape_clone_structure (line 1096) | def reshape_clone_structure(new_shape) #:nodoc:
method to_a_rec (line 1109) | def to_a_rec(dimen = 0) #:nodoc:
method __sparse_initial_set__ (line 1122) | def __sparse_initial_set__(ary) #:nodoc:
method dense_eql_sparse? (line 1139) | def dense_eql_sparse? m #:nodoc:
method maybe_get_noncomplex_default_value (line 1156) | def maybe_get_noncomplex_default_value(to_dtype) #:nodoc:
FILE: lib/nmatrix/rspec.rb
type RSpec::Matchers::BuiltIn (line 32) | module RSpec::Matchers::BuiltIn
class BeWithin (line 33) | class BeWithin
method of (line 35) | def of(expected)
method percent_of (line 53) | def percent_of(expected)
method matches? (line 60) | def matches?(actual)
FILE: lib/nmatrix/shortcuts.rb
class NMatrix (line 35) | class NMatrix
type MagicHelpers (line 38) | module MagicHelpers
function odd_magic (line 40) | def odd_magic(nm, shape)
function doubly_even_magic (line 55) | def doubly_even_magic(nm, shape)
function singly_even_magic (line 78) | def singly_even_magic(nm, shape)
method dense? (line 127) | def dense?; return stype == :dense; end
method yale? (line 133) | def yale?; return stype == :yale; end
method list? (line 139) | def list?; return stype == :list; end
method [] (line 186) | def [](*params)
method zeros (line 232) | def zeros(shape, opts = {})
method ones (line 257) | def ones(shape, opts={})
method ones_like (line 270) | def ones_like(nm)
method zeros_like (line 283) | def zeros_like(nm)
method eye (line 315) | def eye(shape, opts={})
method hilbert (line 347) | def hilbert(shape, opts={})
method inv_hilbert (line 379) | def inv_hilbert(shape, opts={})
method diagonal (line 431) | def diagonal(entries, opts={})
method block_diagonal (line 479) | def block_diagonal(*params)
method random (line 536) | def random(shape, opts={})
method magic (line 596) | def magic(shape, opts={})
method linspace (line 644) | def linspace(base, limit, shape = [100])
method logspace (line 698) | def logspace(base, limit, shape = [50], exponent_base: 10)
method linspace (line 744) | def linspace(base, limit, shape = [100])
method logspace (line 798) | def logspace(base, limit, shape = [50], exponent_base: 10)
method seq (line 838) | def seq(shape, options={})
type NVector (line 855) | module NVector #:nodoc:
function new (line 880) | def new(*args)
function zeros (line 916) | def zeros(size, dtype = :float64)
function ones (line 944) | def ones(size, dtype = :float64)
function random (line 966) | def random(size, opts = {})
function seq (line 998) | def seq(size, dtype = :int64)
function indgen (line 1015) | def indgen(n)
function findgen (line 1030) | def findgen(n)
function bindgen (line 1045) | def bindgen(n)
function cindgen (line 1060) | def cindgen(n)
function linspace (line 1093) | def linspace(a, b, n = 100)
function logspace (line 1137) | def logspace(a, b, n = 100)
FILE: lib/nmatrix/version.rb
class NMatrix (line 25) | class NMatrix
type VERSION (line 29) | module VERSION #:nodoc:
FILE: lib/nmatrix/yale_functions.rb
type NMatrix::YaleFunctions (line 32) | module NMatrix::YaleFunctions
function yale_nd_row_size (line 37) | def yale_nd_row_size i
function yale_ja_at (line 45) | def yale_ja_at i
function yale_ja_set_at (line 54) | def yale_ja_set_at i
function yale_ja_sorted_set_at (line 64) | def yale_ja_sorted_set_at i
function yale_nd_row_as_hash (line 74) | def yale_nd_row_as_hash i
function yale_ja_d_keys_at (line 82) | def yale_ja_d_keys_at i
function yale_ja_d_keys_set_at (line 93) | def yale_ja_d_keys_set_at i
function yale_ja_d_keys_sorted_set_at (line 103) | def yale_ja_d_keys_sorted_set_at i
function yale_row_as_hash (line 113) | def yale_row_as_hash i
FILE: scripts/switch_lapack_ubuntu.rb
function run (line 17) | def run(cmd)
FILE: scripts/ttable_helper.rb
function nullify (line 18) | def nullify(disabled = []) #:nodoc:
FILE: spec/io/harwell_boeing_spec.rb
function check_file_header (line 32) | def check_file_header header
FILE: spec/rspec_monkeys.rb
type RSpec::Matchers::BuiltIn (line 28) | module RSpec::Matchers::BuiltIn
class BeWithin (line 29) | class BeWithin
method of (line 31) | def of(expected)
method percent_of (line 49) | def percent_of(expected)
FILE: spec/spec_helper.rb
function create_matrix (line 74) | def create_matrix(stype) #:nodoc:
function create_rectangular_matrix (line 90) | def create_rectangular_matrix(stype) #:nodoc:
function create_vector (line 127) | def create_vector(stype) #:nodoc:
function nm_eql (line 145) | def nm_eql(n, m) #:nodoc:
function integer_dtype? (line 161) | def integer_dtype? dtype
Condensed preview — 285 files, each showing path, character count, and a content snippet. Download the .json file or copy for the full structured content (3,273K chars).
[
{
"path": ".gitignore",
"chars": 528,
"preview": ".idea\nGemfile.lock\next/nmatrix/dense/daxpy.c\next/nmatrix/dense/dgeco.c\next/nmatrix/dense/dgefa.c\next/nmatrix/dense/dgemm"
},
{
"path": ".rspec",
"chars": 43,
"preview": "--color\n--format RSpec::Longrun::Formatter\n"
},
{
"path": ".travis.yml",
"chars": 3530,
"preview": "language: ruby\nsudo: required\ncache: bundler\nos:\n - linux\n - osx\nosx_image: xcode7.2\nenv:\n - USE_ATLAS=1 # This"
},
{
"path": "CONTRIBUTING.md",
"chars": 5185,
"preview": "NMatrix is part of SciRuby, a collaborative effort to bring scientific\ncomputation to Ruby. If you want to help, please "
},
{
"path": "Gemfile",
"chars": 268,
"preview": "source 'https://rubygems.org'\n\n#main gemspec\ngemspec :name => 'nmatrix'\n\n#plugin gemspecs\nDir['nmatrix-*.gemspec'].each "
},
{
"path": "History.txt",
"chars": 27077,
"preview": "=== 0.0.1 / 2012-04-10\n\n* 1 major enhancement\n\n * Initial alpha release\n\n=== 0.0.2 / 2012-09-21\n\n* 15 major enhancement"
},
{
"path": "LICENSE.txt",
"chars": 1846,
"preview": "This version of NMatrix is licensed under the BSD 3-clause license.\n\n* http://sciruby.com\n* http://github.com/sciruby/sc"
},
{
"path": "Manifest.txt",
"chars": 10264,
"preview": "History.txt\nManifest.txt\nREADME.rdoc\nLICENSE.txt\nCONTRIBUTING.md\nRakefile\nGemfile\nnmatrix.gemspec\nnmatrix-atlas.gemspec\n"
},
{
"path": "README.rdoc",
"chars": 9639,
"preview": "= NMatrix\n\n{<img src=\"https://badges.gitter.im/SciRuby/nmatrix.svg\" alt=\"Join the chat at https://gitter.im/SciRuby/nmat"
},
{
"path": "Rakefile",
"chars": 9465,
"preview": "# -*- ruby -*-\n\nrequire 'rubygems'\nrequire 'rubygems/package_task'\nrequire 'bundler'\n\n#Specify plugins to build on the c"
},
{
"path": "ext/nmatrix/binary_format.txt",
"chars": 1878,
"preview": "This is the proposed binary format for saving and loading NMatrix objects.\n\nOrder is little-endian.\n\nList matrices shoul"
},
{
"path": "ext/nmatrix/data/complex.h",
"chars": 12998,
"preview": "/////////////////////////////////////////////////////////////////////\n// = NMatrix\n//\n// A linear algebra library for sc"
},
{
"path": "ext/nmatrix/data/data.cpp",
"chars": 7232,
"preview": "/////////////////////////////////////////////////////////////////////\n// = NMatrix\n//\n// A linear algebra library for sc"
},
{
"path": "ext/nmatrix/data/data.h",
"chars": 84196,
"preview": "/////////////////////////////////////////////////////////////////////\n// = NMatrix\n//\n// A linear algebra library for sc"
},
{
"path": "ext/nmatrix/data/meta.h",
"chars": 2913,
"preview": "/////////////////////////////////////////////////////////////////////\n// = NMatrix\n//\n// A linear algebra library for sc"
},
{
"path": "ext/nmatrix/data/ruby_object.h",
"chars": 12829,
"preview": "/////////////////////////////////////////////////////////////////////\n// = NMatrix\n//\n// A linear algebra library for sc"
},
{
"path": "ext/nmatrix/extconf.rb",
"chars": 2375,
"preview": "# = NMatrix\n#\n# A linear algebra library for scientific computation in Ruby.\n# NMatrix is part of SciRuby.\n#\n# NMatrix w"
},
{
"path": "ext/nmatrix/math/asum.h",
"chars": 3558,
"preview": "/////////////////////////////////////////////////////////////////////\n// = NMatrix\n//\n// A linear algebra library for sc"
},
{
"path": "ext/nmatrix/math/cblas_enums.h",
"chars": 1170,
"preview": "/////////////////////////////////////////////////////////////////////\n// = NMatrix\n//\n// A linear algebra library for sc"
},
{
"path": "ext/nmatrix/math/cblas_templates_core.h",
"chars": 21740,
"preview": "/////////////////////////////////////////////////////////////////////\n// = NMatrix\n//\n// A linear algebra library for sc"
},
{
"path": "ext/nmatrix/math/gemm.h",
"chars": 6835,
"preview": "/////////////////////////////////////////////////////////////////////\n// = NMatrix\n//\n// A linear algebra library for sc"
},
{
"path": "ext/nmatrix/math/gemv.h",
"chars": 4384,
"preview": "/////////////////////////////////////////////////////////////////////\n// = NMatrix\n//\n// A linear algebra library for sc"
},
{
"path": "ext/nmatrix/math/getrf.h",
"chars": 9024,
"preview": "/////////////////////////////////////////////////////////////////////\n// = NMatrix\n//\n// A linear algebra library for sc"
},
{
"path": "ext/nmatrix/math/getrs.h",
"chars": 5023,
"preview": "/////////////////////////////////////////////////////////////////////\n// = NMatrix\n//\n// A linear algebra library for sc"
},
{
"path": "ext/nmatrix/math/imax.h",
"chars": 1803,
"preview": "/////////////////////////////////////////////////////////////////////\n// = NMatrix\n//\n// A linear algebra library for sc"
},
{
"path": "ext/nmatrix/math/laswp.h",
"chars": 4823,
"preview": "/////////////////////////////////////////////////////////////////////\n// = NMatrix\n//\n// A linear algebra library for sc"
},
{
"path": "ext/nmatrix/math/long_dtype.h",
"chars": 2703,
"preview": "/////////////////////////////////////////////////////////////////////\n// = NMatrix\n//\n// A linear algebra library for sc"
},
{
"path": "ext/nmatrix/math/magnitude.h",
"chars": 2029,
"preview": "/////////////////////////////////////////////////////////////////////\n// = NMatrix\n//\n// A linear algebra library for sc"
},
{
"path": "ext/nmatrix/math/math.h",
"chars": 23283,
"preview": "/////////////////////////////////////////////////////////////////////\n// = NMatrix\n//\n// A linear algebra library for sc"
},
{
"path": "ext/nmatrix/math/nrm2.h",
"chars": 5106,
"preview": "/////////////////////////////////////////////////////////////////////\n// = NMatrix\n//\n// A linear algebra library for sc"
},
{
"path": "ext/nmatrix/math/rot.h",
"chars": 4192,
"preview": "/////////////////////////////////////////////////////////////////////\n// = NMatrix\n//\n// A linear algebra library for sc"
},
{
"path": "ext/nmatrix/math/rotg.h",
"chars": 3756,
"preview": "/////////////////////////////////////////////////////////////////////\n// = NMatrix\n//\n// A linear algebra library for sc"
},
{
"path": "ext/nmatrix/math/scal.h",
"chars": 1828,
"preview": "/////////////////////////////////////////////////////////////////////\n// = NMatrix\n//\n// A linear algebra library for sc"
},
{
"path": "ext/nmatrix/math/trsm.h",
"chars": 11148,
"preview": "/////////////////////////////////////////////////////////////////////\n// = NMatrix\n//\n// A linear algebra library for sc"
},
{
"path": "ext/nmatrix/math/util.h",
"chars": 5836,
"preview": "/////////////////////////////////////////////////////////////////////\n// = NMatrix\n//\n// A linear algebra library for sc"
},
{
"path": "ext/nmatrix/math.cpp",
"chars": 53792,
"preview": "/////////////////////////////////////////////////////////////////////\n// = NMatrix\n//\n// A linear algebra library for sc"
},
{
"path": "ext/nmatrix/nm_memory.h",
"chars": 1703,
"preview": "/////////////////////////////////////////////////////////////////////\n// = NMatrix\n//\n// A linear algebra library for sc"
},
{
"path": "ext/nmatrix/nmatrix.cpp",
"chars": 8999,
"preview": "/////////////////////////////////////////////////////////////////////\n// = NMatrix\n//\n// A linear algebra library for sc"
},
{
"path": "ext/nmatrix/nmatrix.h",
"chars": 15951,
"preview": "/////////////////////////////////////////////////////////////////////\n// = NMatrix\n//\n// A linear algebra library for sc"
},
{
"path": "ext/nmatrix/ruby_constants.cpp",
"chars": 3633,
"preview": "/////////////////////////////////////////////////////////////////////\n// = NMatrix\n//\n// A linear algebra library for sc"
},
{
"path": "ext/nmatrix/ruby_constants.h",
"chars": 2153,
"preview": "/////////////////////////////////////////////////////////////////////\n// = NMatrix\n//\n// A linear algebra library for sc"
},
{
"path": "ext/nmatrix/ruby_nmatrix.c",
"chars": 100764,
"preview": "/////////////////////////////////////////////////////////////////////\n// = NMatrix\n//\n// A linear algebra library for sc"
},
{
"path": "ext/nmatrix/storage/common.cpp",
"chars": 1638,
"preview": "/////////////////////////////////////////////////////////////////////\n// = NMatrix\n//\n// A linear algebra library for sc"
},
{
"path": "ext/nmatrix/storage/common.h",
"chars": 5578,
"preview": "/////////////////////////////////////////////////////////////////////\n// = NMatrix\n//\n// A linear algebra library for sc"
},
{
"path": "ext/nmatrix/storage/dense/dense.cpp",
"chars": 33632,
"preview": "/////////////////////////////////////////////////////////////////////\n// = NMatrix\n//\n// A linear algebra library for sc"
},
{
"path": "ext/nmatrix/storage/dense/dense.h",
"chars": 3108,
"preview": "/////////////////////////////////////////////////////////////////////\n// = NMatrix\n//\n// A linear algebra library for sc"
},
{
"path": "ext/nmatrix/storage/list/list.cpp",
"chars": 53509,
"preview": "/////////////////////////////////////////////////////////////////////\n// = NMatrix\n//\n// A linear algebra library for sc"
},
{
"path": "ext/nmatrix/storage/list/list.h",
"chars": 3792,
"preview": "/////////////////////////////////////////////////////////////////////\n// = NMatrix\n//\n// A linear algebra library for sc"
},
{
"path": "ext/nmatrix/storage/storage.cpp",
"chars": 25429,
"preview": "/////////////////////////////////////////////////////////////////////\n// = NMatrix\n//\n// A linear algebra library for sc"
},
{
"path": "ext/nmatrix/storage/storage.h",
"chars": 2504,
"preview": "/////////////////////////////////////////////////////////////////////\n// = NMatrix\n//\n// A linear algebra library for sc"
},
{
"path": "ext/nmatrix/storage/yale/class.h",
"chars": 39036,
"preview": "/////////////////////////////////////////////////////////////////////\n// = NMatrix\n//\n// A linear algebra library for sc"
},
{
"path": "ext/nmatrix/storage/yale/iterators/base.h",
"chars": 4168,
"preview": "/////////////////////////////////////////////////////////////////////\n// = NMatrix\n//\n// A linear algebra library for sc"
},
{
"path": "ext/nmatrix/storage/yale/iterators/iterator.h",
"chars": 4395,
"preview": "/////////////////////////////////////////////////////////////////////\n// = NMatrix\n//\n// A linear algebra library for sc"
},
{
"path": "ext/nmatrix/storage/yale/iterators/row.h",
"chars": 16626,
"preview": "/////////////////////////////////////////////////////////////////////\n// = NMatrix\n//\n// A linear algebra library for sc"
},
{
"path": "ext/nmatrix/storage/yale/iterators/row_stored.h",
"chars": 4478,
"preview": "/////////////////////////////////////////////////////////////////////\n// = NMatrix\n//\n// A linear algebra library for sc"
},
{
"path": "ext/nmatrix/storage/yale/iterators/row_stored_nd.h",
"chars": 4834,
"preview": "/////////////////////////////////////////////////////////////////////\n// = NMatrix\n//\n// A linear algebra library for sc"
},
{
"path": "ext/nmatrix/storage/yale/iterators/stored_diagonal.h",
"chars": 4316,
"preview": "/////////////////////////////////////////////////////////////////////\n// = NMatrix\n//\n// A linear algebra library for sc"
},
{
"path": "ext/nmatrix/storage/yale/math/transpose.h",
"chars": 2462,
"preview": "/////////////////////////////////////////////////////////////////////\n// = NMatrix\n//\n// A linear algebra library for sc"
},
{
"path": "ext/nmatrix/storage/yale/yale.cpp",
"chars": 63811,
"preview": "/////////////////////////////////////////////////////////////////////\n// = NMatrix\n//\n// A linear algebra library for sc"
},
{
"path": "ext/nmatrix/storage/yale/yale.h",
"chars": 5757,
"preview": "/////////////////////////////////////////////////////////////////////\n// = NMatrix\n//\n// A linear algebra library for sc"
},
{
"path": "ext/nmatrix/types.h",
"chars": 1169,
"preview": "/////////////////////////////////////////////////////////////////////\n// = NMatrix\n//\n// A linear algebra library for sc"
},
{
"path": "ext/nmatrix/util/io.cpp",
"chars": 7753,
"preview": "/////////////////////////////////////////////////////////////////////\n// = NMatrix\n//\n// A linear algebra library for sc"
},
{
"path": "ext/nmatrix/util/io.h",
"chars": 4535,
"preview": "/////////////////////////////////////////////////////////////////////\n// = NMatrix\n//\n// A linear algebra library for sc"
},
{
"path": "ext/nmatrix/util/sl_list.cpp",
"chars": 15254,
"preview": "/////////////////////////////////////////////////////////////////////\n// = NMatrix\n//\n// A linear algebra library for sc"
},
{
"path": "ext/nmatrix/util/sl_list.h",
"chars": 3440,
"preview": "/////////////////////////////////////////////////////////////////////\n// = NMatrix\n//\n// A linear algebra library for sc"
},
{
"path": "ext/nmatrix/util/util.h",
"chars": 1306,
"preview": "/////////////////////////////////////////////////////////////////////\n// = NMatrix\n//\n// A linear algebra library for sc"
},
{
"path": "ext/nmatrix_atlas/extconf.rb",
"chars": 4889,
"preview": "# = NMatrix\n#\n# A linear algebra library for scientific computation in Ruby.\n# NMatrix is part of SciRuby.\n#\n# NMatrix w"
},
{
"path": "ext/nmatrix_atlas/math_atlas/cblas_templates_atlas.h",
"chars": 2122,
"preview": "/////////////////////////////////////////////////////////////////////\n// = NMatrix\n//\n// A linear algebra library for sc"
},
{
"path": "ext/nmatrix_atlas/math_atlas/clapack_templates.h",
"chars": 12610,
"preview": "/////////////////////////////////////////////////////////////////////\n// = NMatrix\n//\n// A linear algebra library for sc"
},
{
"path": "ext/nmatrix_atlas/math_atlas/geev.h",
"chars": 3953,
"preview": "/////////////////////////////////////////////////////////////////////\n// = NMatrix\n//\n// A linear algebra library for sc"
},
{
"path": "ext/nmatrix_atlas/math_atlas/gesdd.h",
"chars": 3320,
"preview": "/////////////////////////////////////////////////////////////////////\n// = NMatrix\n//\n// A linear algebra library for sc"
},
{
"path": "ext/nmatrix_atlas/math_atlas/gesvd.h",
"chars": 3326,
"preview": "/////////////////////////////////////////////////////////////////////\n// = NMatrix\n//\n// A linear algebra library for sc"
},
{
"path": "ext/nmatrix_atlas/math_atlas/inc.h",
"chars": 1213,
"preview": "/////////////////////////////////////////////////////////////////////\n// = NMatrix\n//\n// A linear algebra library for sc"
},
{
"path": "ext/nmatrix_atlas/math_atlas.cpp",
"chars": 52580,
"preview": "/////////////////////////////////////////////////////////////////////\n// = NMatrix\n//\n// A linear algebra library for sc"
},
{
"path": "ext/nmatrix_atlas/nmatrix_atlas.cpp",
"chars": 1005,
"preview": "/////////////////////////////////////////////////////////////////////\n// = NMatrix\n//\n// A linear algebra library for sc"
},
{
"path": "ext/nmatrix_fftw/extconf.rb",
"chars": 1783,
"preview": "# = NMatrix\n#\n# A linear algebra library for scientific computation in Ruby.\n# NMatrix is part of SciRuby.\n#\n# NMatrix w"
},
{
"path": "ext/nmatrix_fftw/nmatrix_fftw.cpp",
"chars": 9751,
"preview": "/////////////////////////////////////////////////////////////////////\n// = NMatrix\n//\n// A linear algebra library for sc"
},
{
"path": "ext/nmatrix_java/nmatrix/math/MathHelper.java",
"chars": 3037,
"preview": "import org.apache.commons.math3.util.FastMath;\nimport org.apache.commons.math3.special.Erf;\nimport org.apache.commons.ma"
},
{
"path": "ext/nmatrix_java/nmatrix/storage/dense/ArrayComparator.java",
"chars": 277,
"preview": "public class ArrayComparator{\n\n public static boolean equals(double[] arr1, double[] arr2){\n\n double delta = 1e-3;\n "
},
{
"path": "ext/nmatrix_java/nmatrix/util/ArrayGenerator.java",
"chars": 1917,
"preview": "public class ArrayGenerator{\n // Array from Matrix begin\n\n public static double[] getArrayDouble(double[][] matrix, in"
},
{
"path": "ext/nmatrix_java/nmatrix/util/MatrixGenerator.java",
"chars": 1035,
"preview": "public class MatrixGenerator\n{ \n\n // Matrix from Array begin\n public static float[][] getMatrixFloat(float[] array, in"
},
{
"path": "ext/nmatrix_java/nmatrix/util/WrapperType.java",
"chars": 893,
"preview": "//http://stackoverflow.com/questions/709961/determining-if-an-object-is-of-primitive-type\n\nimport java.util.*;\n\npublic c"
},
{
"path": "ext/nmatrix_java/test/AssertTests.java",
"chars": 3061,
"preview": "import static org.hamcrest.CoreMatchers.allOf;\nimport static org.hamcrest.CoreMatchers.anyOf;\nimport static org.hamcrest"
},
{
"path": "ext/nmatrix_java/test/TestRunner.java",
"chars": 173,
"preview": "public class TestRunner{\n\tpublic static void main(String[] args) {\n\t\tAssertTests test1 = new AssertTests();\n\t\ttest1.test"
},
{
"path": "ext/nmatrix_lapacke/extconf.rb",
"chars": 3182,
"preview": "# = NMatrix\n#\n# A linear algebra library for scientific computation in Ruby.\n# NMatrix is part of SciRuby.\n#\n# NMatrix w"
},
{
"path": "ext/nmatrix_lapacke/lapacke/include/lapacke.h",
"chars": 1068297,
"preview": "/*****************************************************************************\n Copyright (c) 2010, Intel Corp.\n All r"
},
{
"path": "ext/nmatrix_lapacke/lapacke/include/lapacke_config.h",
"chars": 4236,
"preview": "/*****************************************************************************\n Copyright (c) 2010, Intel Corp.\n All r"
},
{
"path": "ext/nmatrix_lapacke/lapacke/include/lapacke_mangling.h",
"chars": 474,
"preview": "#ifndef LAPACK_HEADER_INCLUDED\n#define LAPACK_HEADER_INCLUDED\n\n#ifndef LAPACK_GLOBAL\n#if defined(LAPACK_GLOBAL_PATTERN_L"
},
{
"path": "ext/nmatrix_lapacke/lapacke/include/lapacke_mangling_with_flags.h",
"chars": 474,
"preview": "#ifndef LAPACK_HEADER_INCLUDED\n#define LAPACK_HEADER_INCLUDED\n\n#ifndef LAPACK_GLOBAL\n#if defined(LAPACK_GLOBAL_PATTERN_L"
},
{
"path": "ext/nmatrix_lapacke/lapacke/include/lapacke_utils.h",
"chars": 33047,
"preview": "/*****************************************************************************\n Copyright (c) 2010, Intel Corp.\n All r"
},
{
"path": "ext/nmatrix_lapacke/lapacke/src/lapacke_cgeev.c",
"chars": 3923,
"preview": "/*****************************************************************************\n Copyright (c) 2011, Intel Corp.\n All r"
},
{
"path": "ext/nmatrix_lapacke/lapacke/src/lapacke_cgeev_work.c",
"chars": 6037,
"preview": "/*****************************************************************************\n Copyright (c) 2011, Intel Corp.\n All r"
},
{
"path": "ext/nmatrix_lapacke/lapacke/src/lapacke_cgeqrf.c",
"chars": 3409,
"preview": "/*****************************************************************************\n Copyright (c) 2014, Intel Corp.\n All r"
},
{
"path": "ext/nmatrix_lapacke/lapacke/src/lapacke_cgeqrf_work.c",
"chars": 4034,
"preview": "/*****************************************************************************\n Copyright (c) 2014, Intel Corp.\n All r"
},
{
"path": "ext/nmatrix_lapacke/lapacke/src/lapacke_cgesdd.c",
"chars": 4481,
"preview": "/*****************************************************************************\n Copyright (c) 2011, Intel Corp.\n All r"
},
{
"path": "ext/nmatrix_lapacke/lapacke/src/lapacke_cgesdd_work.c",
"chars": 7281,
"preview": "/*****************************************************************************\n Copyright (c) 2011, Intel Corp.\n All r"
},
{
"path": "ext/nmatrix_lapacke/lapacke/src/lapacke_cgesvd.c",
"chars": 4099,
"preview": "/*****************************************************************************\n Copyright (c) 2011, Intel Corp.\n All r"
},
{
"path": "ext/nmatrix_lapacke/lapacke/src/lapacke_cgesvd_work.c",
"chars": 6737,
"preview": "/*****************************************************************************\n Copyright (c) 2011, Intel Corp.\n All r"
},
{
"path": "ext/nmatrix_lapacke/lapacke/src/lapacke_cgetrf.c",
"chars": 2525,
"preview": "/*****************************************************************************\n Copyright (c) 2011, Intel Corp.\n All r"
},
{
"path": "ext/nmatrix_lapacke/lapacke/src/lapacke_cgetrf_work.c",
"chars": 3692,
"preview": "/*****************************************************************************\n Copyright (c) 2011, Intel Corp.\n All r"
},
{
"path": "ext/nmatrix_lapacke/lapacke/src/lapacke_cgetri.c",
"chars": 3383,
"preview": "/*****************************************************************************\n Copyright (c) 2011, Intel Corp.\n All r"
},
{
"path": "ext/nmatrix_lapacke/lapacke/src/lapacke_cgetri_work.c",
"chars": 4005,
"preview": "/*****************************************************************************\n Copyright (c) 2011, Intel Corp.\n All r"
},
{
"path": "ext/nmatrix_lapacke/lapacke/src/lapacke_cgetrs.c",
"chars": 2761,
"preview": "/*****************************************************************************\n Copyright (c) 2011, Intel Corp.\n All r"
},
{
"path": "ext/nmatrix_lapacke/lapacke/src/lapacke_cgetrs_work.c",
"chars": 4467,
"preview": "/*****************************************************************************\n Copyright (c) 2011, Intel Corp.\n All r"
},
{
"path": "ext/nmatrix_lapacke/lapacke/src/lapacke_cpotrf.c",
"chars": 2477,
"preview": "/*****************************************************************************\n Copyright (c) 2011, Intel Corp.\n All r"
},
{
"path": "ext/nmatrix_lapacke/lapacke/src/lapacke_cpotrf_work.c",
"chars": 3639,
"preview": "/*****************************************************************************\n Copyright (c) 2011, Intel Corp.\n All r"
},
{
"path": "ext/nmatrix_lapacke/lapacke/src/lapacke_cpotri.c",
"chars": 2477,
"preview": "/*****************************************************************************\n Copyright (c) 2011, Intel Corp.\n All r"
},
{
"path": "ext/nmatrix_lapacke/lapacke/src/lapacke_cpotri_work.c",
"chars": 3639,
"preview": "/*****************************************************************************\n Copyright (c) 2011, Intel Corp.\n All r"
},
{
"path": "ext/nmatrix_lapacke/lapacke/src/lapacke_cpotrs.c",
"chars": 2700,
"preview": "/*****************************************************************************\n Copyright (c) 2011, Intel Corp.\n All r"
},
{
"path": "ext/nmatrix_lapacke/lapacke/src/lapacke_cpotrs_work.c",
"chars": 4408,
"preview": "/*****************************************************************************\n Copyright (c) 2011, Intel Corp.\n All r"
},
{
"path": "ext/nmatrix_lapacke/lapacke/src/lapacke_cunmqr.c",
"chars": 3854,
"preview": "/*****************************************************************************\n Copyright (c) 2014, Intel Corp.\n All r"
},
{
"path": "ext/nmatrix_lapacke/lapacke/src/lapacke_cunmqr_work.c",
"chars": 4980,
"preview": "/*****************************************************************************\n Copyright (c) 2014, Intel Corp.\n All r"
},
{
"path": "ext/nmatrix_lapacke/lapacke/src/lapacke_dgeev.c",
"chars": 3502,
"preview": "/*****************************************************************************\n Copyright (c) 2011, Intel Corp.\n All r"
},
{
"path": "ext/nmatrix_lapacke/lapacke/src/lapacke_dgeev_work.c",
"chars": 5696,
"preview": "/*****************************************************************************\n Copyright (c) 2011, Intel Corp.\n All r"
},
{
"path": "ext/nmatrix_lapacke/lapacke/src/lapacke_dgeqrf.c",
"chars": 3285,
"preview": "/*****************************************************************************\n Copyright (c) 2014, Intel Corp.\n All r"
},
{
"path": "ext/nmatrix_lapacke/lapacke/src/lapacke_dgeqrf_work.c",
"chars": 3905,
"preview": "/*****************************************************************************\n Copyright (c) 2014, Intel Corp.\n All r"
},
{
"path": "ext/nmatrix_lapacke/lapacke/src/lapacke_dgesdd.c",
"chars": 3799,
"preview": "/*****************************************************************************\n Copyright (c) 2011, Intel Corp.\n All r"
},
{
"path": "ext/nmatrix_lapacke/lapacke/src/lapacke_dgesdd_work.c",
"chars": 6924,
"preview": "/*****************************************************************************\n Copyright (c) 2011, Intel Corp.\n All r"
},
{
"path": "ext/nmatrix_lapacke/lapacke/src/lapacke_dgesvd.c",
"chars": 3664,
"preview": "/*****************************************************************************\n Copyright (c) 2011, Intel Corp.\n All r"
},
{
"path": "ext/nmatrix_lapacke/lapacke/src/lapacke_dgesvd_work.c",
"chars": 6380,
"preview": "/*****************************************************************************\n Copyright (c) 2011, Intel Corp.\n All r"
},
{
"path": "ext/nmatrix_lapacke/lapacke/src/lapacke_dgetrf.c",
"chars": 2484,
"preview": "/*****************************************************************************\n Copyright (c) 2011, Intel Corp.\n All r"
},
{
"path": "ext/nmatrix_lapacke/lapacke/src/lapacke_dgetrf_work.c",
"chars": 3591,
"preview": "/*****************************************************************************\n Copyright (c) 2011, Intel Corp.\n All r"
},
{
"path": "ext/nmatrix_lapacke/lapacke/src/lapacke_dgetri.c",
"chars": 3273,
"preview": "/*****************************************************************************\n Copyright (c) 2011, Intel Corp.\n All r"
},
{
"path": "ext/nmatrix_lapacke/lapacke/src/lapacke_dgetri_work.c",
"chars": 3890,
"preview": "/*****************************************************************************\n Copyright (c) 2011, Intel Corp.\n All r"
},
{
"path": "ext/nmatrix_lapacke/lapacke/src/lapacke_dgetrs.c",
"chars": 2706,
"preview": "/*****************************************************************************\n Copyright (c) 2011, Intel Corp.\n All r"
},
{
"path": "ext/nmatrix_lapacke/lapacke/src/lapacke_dgetrs_work.c",
"chars": 4301,
"preview": "/*****************************************************************************\n Copyright (c) 2011, Intel Corp.\n All r"
},
{
"path": "ext/nmatrix_lapacke/lapacke/src/lapacke_dormqr.c",
"chars": 3716,
"preview": "/*****************************************************************************\n Copyright (c) 2014, Intel Corp.\n All r"
},
{
"path": "ext/nmatrix_lapacke/lapacke/src/lapacke_dormqr_work.c",
"chars": 4777,
"preview": "/*****************************************************************************\n Copyright (c) 2014, Intel Corp.\n All r"
},
{
"path": "ext/nmatrix_lapacke/lapacke/src/lapacke_dpotrf.c",
"chars": 2463,
"preview": "/*****************************************************************************\n Copyright (c) 2011, Intel Corp.\n All r"
},
{
"path": "ext/nmatrix_lapacke/lapacke/src/lapacke_dpotrf_work.c",
"chars": 3570,
"preview": "/*****************************************************************************\n Copyright (c) 2011, Intel Corp.\n All r"
},
{
"path": "ext/nmatrix_lapacke/lapacke/src/lapacke_dpotri.c",
"chars": 2463,
"preview": "/*****************************************************************************\n Copyright (c) 2011, Intel Corp.\n All r"
},
{
"path": "ext/nmatrix_lapacke/lapacke/src/lapacke_dpotri_work.c",
"chars": 3570,
"preview": "/*****************************************************************************\n Copyright (c) 2011, Intel Corp.\n All r"
},
{
"path": "ext/nmatrix_lapacke/lapacke/src/lapacke_dpotrs.c",
"chars": 2645,
"preview": "/*****************************************************************************\n Copyright (c) 2011, Intel Corp.\n All r"
},
{
"path": "ext/nmatrix_lapacke/lapacke/src/lapacke_dpotrs_work.c",
"chars": 4210,
"preview": "/*****************************************************************************\n Copyright (c) 2011, Intel Corp.\n All r"
},
{
"path": "ext/nmatrix_lapacke/lapacke/src/lapacke_sgeev.c",
"chars": 3493,
"preview": "/*****************************************************************************\n Copyright (c) 2011, Intel Corp.\n All r"
},
{
"path": "ext/nmatrix_lapacke/lapacke/src/lapacke_sgeev_work.c",
"chars": 5647,
"preview": "/*****************************************************************************\n Copyright (c) 2011, Intel Corp.\n All r"
},
{
"path": "ext/nmatrix_lapacke/lapacke/src/lapacke_sgeqrf.c",
"chars": 3279,
"preview": "/*****************************************************************************\n Copyright (c) 2014, Intel Corp.\n All r"
},
{
"path": "ext/nmatrix_lapacke/lapacke/src/lapacke_sgeqrf_work.c",
"chars": 3899,
"preview": "/*****************************************************************************\n Copyright (c) 2014, Intel Corp.\n All r"
},
{
"path": "ext/nmatrix_lapacke/lapacke/src/lapacke_sgesdd.c",
"chars": 3791,
"preview": "/*****************************************************************************\n Copyright (c) 2011, Intel Corp.\n All r"
},
{
"path": "ext/nmatrix_lapacke/lapacke/src/lapacke_sgesdd_work.c",
"chars": 6893,
"preview": "/*****************************************************************************\n Copyright (c) 2011, Intel Corp.\n All r"
},
{
"path": "ext/nmatrix_lapacke/lapacke/src/lapacke_sgesvd.c",
"chars": 3655,
"preview": "/*****************************************************************************\n Copyright (c) 2011, Intel Corp.\n All r"
},
{
"path": "ext/nmatrix_lapacke/lapacke/src/lapacke_sgesvd_work.c",
"chars": 6349,
"preview": "/*****************************************************************************\n Copyright (c) 2011, Intel Corp.\n All r"
},
{
"path": "ext/nmatrix_lapacke/lapacke/src/lapacke_sgetrf.c",
"chars": 2483,
"preview": "/*****************************************************************************\n Copyright (c) 2011, Intel Corp.\n All r"
},
{
"path": "ext/nmatrix_lapacke/lapacke/src/lapacke_sgetrf_work.c",
"chars": 3587,
"preview": "/*****************************************************************************\n Copyright (c) 2011, Intel Corp.\n All r"
},
{
"path": "ext/nmatrix_lapacke/lapacke/src/lapacke_sgetri.c",
"chars": 3268,
"preview": "/*****************************************************************************\n Copyright (c) 2011, Intel Corp.\n All r"
},
{
"path": "ext/nmatrix_lapacke/lapacke/src/lapacke_sgetri_work.c",
"chars": 3885,
"preview": "/*****************************************************************************\n Copyright (c) 2011, Intel Corp.\n All r"
},
{
"path": "ext/nmatrix_lapacke/lapacke/src/lapacke_sgetrs.c",
"chars": 2704,
"preview": "/*****************************************************************************\n Copyright (c) 2011, Intel Corp.\n All r"
},
{
"path": "ext/nmatrix_lapacke/lapacke/src/lapacke_sgetrs_work.c",
"chars": 4293,
"preview": "/*****************************************************************************\n Copyright (c) 2011, Intel Corp.\n All r"
},
{
"path": "ext/nmatrix_lapacke/lapacke/src/lapacke_sormqr.c",
"chars": 3709,
"preview": "/*****************************************************************************\n Copyright (c) 2014, Intel Corp.\n All r"
},
{
"path": "ext/nmatrix_lapacke/lapacke/src/lapacke_sormqr_work.c",
"chars": 4768,
"preview": "/*****************************************************************************\n Copyright (c) 2014, Intel Corp.\n All r"
},
{
"path": "ext/nmatrix_lapacke/lapacke/src/lapacke_spotrf.c",
"chars": 2462,
"preview": "/*****************************************************************************\n Copyright (c) 2011, Intel Corp.\n All r"
},
{
"path": "ext/nmatrix_lapacke/lapacke/src/lapacke_spotrf_work.c",
"chars": 3566,
"preview": "/*****************************************************************************\n Copyright (c) 2011, Intel Corp.\n All r"
},
{
"path": "ext/nmatrix_lapacke/lapacke/src/lapacke_spotri.c",
"chars": 2462,
"preview": "/*****************************************************************************\n Copyright (c) 2011, Intel Corp.\n All r"
},
{
"path": "ext/nmatrix_lapacke/lapacke/src/lapacke_spotri_work.c",
"chars": 3566,
"preview": "/*****************************************************************************\n Copyright (c) 2011, Intel Corp.\n All r"
},
{
"path": "ext/nmatrix_lapacke/lapacke/src/lapacke_spotrs.c",
"chars": 2643,
"preview": "/*****************************************************************************\n Copyright (c) 2011, Intel Corp.\n All r"
},
{
"path": "ext/nmatrix_lapacke/lapacke/src/lapacke_spotrs_work.c",
"chars": 4202,
"preview": "/*****************************************************************************\n Copyright (c) 2011, Intel Corp.\n All r"
},
{
"path": "ext/nmatrix_lapacke/lapacke/src/lapacke_zgeev.c",
"chars": 3934,
"preview": "/*****************************************************************************\n Copyright (c) 2011, Intel Corp.\n All r"
},
{
"path": "ext/nmatrix_lapacke/lapacke/src/lapacke_zgeev_work.c",
"chars": 6052,
"preview": "/*****************************************************************************\n Copyright (c) 2011, Intel Corp.\n All r"
},
{
"path": "ext/nmatrix_lapacke/lapacke/src/lapacke_zgeqrf.c",
"chars": 3415,
"preview": "/*****************************************************************************\n Copyright (c) 2014, Intel Corp.\n All r"
},
{
"path": "ext/nmatrix_lapacke/lapacke/src/lapacke_zgeqrf_work.c",
"chars": 4040,
"preview": "/*****************************************************************************\n Copyright (c) 2014, Intel Corp.\n All r"
},
{
"path": "ext/nmatrix_lapacke/lapacke/src/lapacke_zgesdd.c",
"chars": 4492,
"preview": "/*****************************************************************************\n Copyright (c) 2011, Intel Corp.\n All r"
},
{
"path": "ext/nmatrix_lapacke/lapacke/src/lapacke_zgesdd_work.c",
"chars": 7296,
"preview": "/*****************************************************************************\n Copyright (c) 2011, Intel Corp.\n All r"
},
{
"path": "ext/nmatrix_lapacke/lapacke/src/lapacke_zgesvd.c",
"chars": 4111,
"preview": "/*****************************************************************************\n Copyright (c) 2011, Intel Corp.\n All r"
},
{
"path": "ext/nmatrix_lapacke/lapacke/src/lapacke_zgesvd_work.c",
"chars": 6752,
"preview": "/*****************************************************************************\n Copyright (c) 2011, Intel Corp.\n All r"
},
{
"path": "ext/nmatrix_lapacke/lapacke/src/lapacke_zgetrf.c",
"chars": 2526,
"preview": "/*****************************************************************************\n Copyright (c) 2011, Intel Corp.\n All r"
},
{
"path": "ext/nmatrix_lapacke/lapacke/src/lapacke_zgetrf_work.c",
"chars": 3696,
"preview": "/*****************************************************************************\n Copyright (c) 2011, Intel Corp.\n All r"
},
{
"path": "ext/nmatrix_lapacke/lapacke/src/lapacke_zgetri.c",
"chars": 3388,
"preview": "/*****************************************************************************\n Copyright (c) 2011, Intel Corp.\n All r"
},
{
"path": "ext/nmatrix_lapacke/lapacke/src/lapacke_zgetri_work.c",
"chars": 4010,
"preview": "/*****************************************************************************\n Copyright (c) 2011, Intel Corp.\n All r"
},
{
"path": "ext/nmatrix_lapacke/lapacke/src/lapacke_zgetrs.c",
"chars": 2763,
"preview": "/*****************************************************************************\n Copyright (c) 2011, Intel Corp.\n All r"
},
{
"path": "ext/nmatrix_lapacke/lapacke/src/lapacke_zgetrs_work.c",
"chars": 4475,
"preview": "/*****************************************************************************\n Copyright (c) 2011, Intel Corp.\n All r"
},
{
"path": "ext/nmatrix_lapacke/lapacke/src/lapacke_zpotrf.c",
"chars": 2478,
"preview": "/*****************************************************************************\n Copyright (c) 2011, Intel Corp.\n All r"
},
{
"path": "ext/nmatrix_lapacke/lapacke/src/lapacke_zpotrf_work.c",
"chars": 3643,
"preview": "/*****************************************************************************\n Copyright (c) 2011, Intel Corp.\n All r"
},
{
"path": "ext/nmatrix_lapacke/lapacke/src/lapacke_zpotri.c",
"chars": 2478,
"preview": "/*****************************************************************************\n Copyright (c) 2011, Intel Corp.\n All r"
},
{
"path": "ext/nmatrix_lapacke/lapacke/src/lapacke_zpotri_work.c",
"chars": 3643,
"preview": "/*****************************************************************************\n Copyright (c) 2011, Intel Corp.\n All r"
},
{
"path": "ext/nmatrix_lapacke/lapacke/src/lapacke_zpotrs.c",
"chars": 2702,
"preview": "/*****************************************************************************\n Copyright (c) 2011, Intel Corp.\n All r"
},
{
"path": "ext/nmatrix_lapacke/lapacke/src/lapacke_zpotrs_work.c",
"chars": 4416,
"preview": "/*****************************************************************************\n Copyright (c) 2011, Intel Corp.\n All r"
},
{
"path": "ext/nmatrix_lapacke/lapacke/src/lapacke_zunmqr.c",
"chars": 3861,
"preview": "/*****************************************************************************\n Copyright (c) 2014, Intel Corp.\n All r"
},
{
"path": "ext/nmatrix_lapacke/lapacke/src/lapacke_zunmqr_work.c",
"chars": 4990,
"preview": "/*****************************************************************************\n Copyright (c) 2014, Intel Corp.\n All r"
},
{
"path": "ext/nmatrix_lapacke/lapacke/utils/lapacke_c_nancheck.c",
"chars": 2419,
"preview": "/*****************************************************************************\n Copyright (c) 2010, Intel Corp.\n All r"
},
{
"path": "ext/nmatrix_lapacke/lapacke/utils/lapacke_cge_nancheck.c",
"chars": 2847,
"preview": "/*****************************************************************************\n Copyright (c) 2010, Intel Corp.\n All r"
},
{
"path": "ext/nmatrix_lapacke/lapacke/utils/lapacke_cge_trans.c",
"chars": 2803,
"preview": "/*****************************************************************************\n Copyright (c) 2010, Intel Corp.\n All r"
},
{
"path": "ext/nmatrix_lapacke/lapacke/utils/lapacke_cpo_nancheck.c",
"chars": 2280,
"preview": "/*****************************************************************************\n Copyright (c) 2010, Intel Corp.\n All r"
},
{
"path": "ext/nmatrix_lapacke/lapacke/utils/lapacke_cpo_trans.c",
"chars": 2322,
"preview": "/*****************************************************************************\n Copyright (c) 2010, Intel Corp.\n All r"
},
{
"path": "ext/nmatrix_lapacke/lapacke/utils/lapacke_ctr_nancheck.c",
"chars": 3688,
"preview": "/*****************************************************************************\n Copyright (c) 2010, Intel Corp.\n All r"
},
{
"path": "ext/nmatrix_lapacke/lapacke/utils/lapacke_ctr_trans.c",
"chars": 3640,
"preview": "/*****************************************************************************\n Copyright (c) 2010, Intel Corp.\n All r"
},
{
"path": "ext/nmatrix_lapacke/lapacke/utils/lapacke_d_nancheck.c",
"chars": 2405,
"preview": "/*****************************************************************************\n Copyright (c) 2010, Intel Corp.\n All r"
},
{
"path": "ext/nmatrix_lapacke/lapacke/utils/lapacke_dge_nancheck.c",
"chars": 2833,
"preview": "/*****************************************************************************\n Copyright (c) 2010, Intel Corp.\n All r"
},
{
"path": "ext/nmatrix_lapacke/lapacke/utils/lapacke_dge_trans.c",
"chars": 2775,
"preview": "/*****************************************************************************\n Copyright (c) 2010, Intel Corp.\n All r"
},
{
"path": "ext/nmatrix_lapacke/lapacke/utils/lapacke_dpo_nancheck.c",
"chars": 2266,
"preview": "/*****************************************************************************\n Copyright (c) 2010, Intel Corp.\n All r"
},
{
"path": "ext/nmatrix_lapacke/lapacke/utils/lapacke_dpo_trans.c",
"chars": 2294,
"preview": "/*****************************************************************************\n Copyright (c) 2010, Intel Corp.\n All r"
},
{
"path": "ext/nmatrix_lapacke/lapacke/utils/lapacke_dtr_nancheck.c",
"chars": 3674,
"preview": "/*****************************************************************************\n Copyright (c) 2010, Intel Corp.\n All r"
},
{
"path": "ext/nmatrix_lapacke/lapacke/utils/lapacke_dtr_trans.c",
"chars": 3612,
"preview": "/*****************************************************************************\n Copyright (c) 2010, Intel Corp.\n All r"
},
{
"path": "ext/nmatrix_lapacke/lapacke/utils/lapacke_lsame.c",
"chars": 2029,
"preview": "/*****************************************************************************\n Copyright (c) 2010, Intel Corp.\n All r"
},
{
"path": "ext/nmatrix_lapacke/lapacke/utils/lapacke_s_nancheck.c",
"chars": 2404,
"preview": "/*****************************************************************************\n Copyright (c) 2010, Intel Corp.\n All r"
},
{
"path": "ext/nmatrix_lapacke/lapacke/utils/lapacke_sge_nancheck.c",
"chars": 2832,
"preview": "/*****************************************************************************\n Copyright (c) 2010, Intel Corp.\n All r"
},
{
"path": "ext/nmatrix_lapacke/lapacke/utils/lapacke_sge_trans.c",
"chars": 2773,
"preview": "/*****************************************************************************\n Copyright (c) 2010, Intel Corp.\n All r"
},
{
"path": "ext/nmatrix_lapacke/lapacke/utils/lapacke_spo_nancheck.c",
"chars": 2265,
"preview": "/*****************************************************************************\n Copyright (c) 2010, Intel Corp.\n All r"
},
{
"path": "ext/nmatrix_lapacke/lapacke/utils/lapacke_spo_trans.c",
"chars": 2292,
"preview": "/*****************************************************************************\n Copyright (c) 2010, Intel Corp.\n All r"
},
{
"path": "ext/nmatrix_lapacke/lapacke/utils/lapacke_str_nancheck.c",
"chars": 3673,
"preview": "/*****************************************************************************\n Copyright (c) 2010, Intel Corp.\n All r"
},
{
"path": "ext/nmatrix_lapacke/lapacke/utils/lapacke_str_trans.c",
"chars": 3610,
"preview": "/*****************************************************************************\n Copyright (c) 2010, Intel Corp.\n All r"
}
]
// ... and 85 more files (download for full content)
About this extraction
This page contains the full source code of the SciRuby/nmatrix GitHub repository, extracted and formatted as plain text for AI agents and large language models (LLMs). The extraction includes 285 files (3.0 MB), approximately 807.4k tokens, and a symbol index with 1556 extracted functions, classes, methods, constants, and types. Use this with OpenClaw, Claude, ChatGPT, Cursor, Windsurf, or any other AI tool that accepts text input. You can copy the full output to your clipboard or download it as a .txt file.
Extracted by GitExtract — free GitHub repo to text converter for AI. Built by Nikandr Surkov.