Methods
* (Matrix)
* (Vector)
** (Matrix)
+ (Vector)
+ (Matrix)
- (Matrix)
- (Vector)
/ (Vector)
/ (Matrix)
<< (Enumerator::Yielder)
<=> (Symbol)
== (Matrix)
== (Vector)
== (Backports::Random::Implementation)
=== (BasicObject)
=~ (Symbol)
[] (Vector)
[] (Matrix)
[] (Backports::Random::MT19937)
[] (OpenStruct)
[] (Hash)
[] (Matrix)
[] (Symbol)
[] (Vector)
[] (Prime::TrialDivision)
[]= (Matrix)
[]= (OpenStruct)
[]= (Vector)
__method__ (Kernel)
__set_inspect (Enumerator::Lazy)
advise (IO)
alias_method (Backports)
alias_method_chain (Backports)
alias_method_chain (Module)
ascii_only? (String)
assoc (Hash)
bind_with_additional_info (UnboundMethod)
binread (IO)
binwrite (IO)
bit_length (Bignum)
bit_length (Fixnum)
bsearch (Array)
bsearch (Range)
build (Matrix)
bytes (Backports::Random::Implementation)
byteslice (String)
cache (Prime::TrialDivision)
camelize (String)
capitalize (Symbol)
casecmp (Symbol)
chars (IO)
chr (String)
chunk (Enumerator::Lazy)
chunk (Enumerable)
clear (String)
clone (Vector)
clone (Matrix)
codepoints (String)
coerce (Vector)
coerce (Matrix)
coerce_to (Backports)
coerce_to_ary (Backports)
coerce_to_comparison (Backports)
coerce_to_hash (Backports)
coerce_to_int (Backports)
coerce_to_option (Backports)
coerce_to_options (Backports)
coerce_to_str (Backports)
collect (Enumerator::Lazy)
collect (Matrix)
collect (Vector)
collect2 (Vector)
collect_concat (Enumerator::Lazy)
collect_concat (Enumerable)
column (Matrix)
column_vector (Matrix)
column_vectors (Matrix)
columns (Matrix)
combination (Array)
combine_mode_and_option (Backports)
combine_mode_perm_and_option (Backports)
component (Matrix)
component (Vector)
conj (Matrix)
conjugate (Matrix)
constantize (String)
convert_all_arguments_to_path (Backports)
convert_first_argument_to_path (Backports)
convert_path (Backports)
convert_seed (Backports::Random::MT19937)
count (Enumerable)
covector (Vector)
curry (Proc)
cycle (Enumerable)
cycle (Array)
d (Matrix::EigenvalueDecomposition)
dasherize (String)
default_proc= (Hash)
default_proc_with_nil= (Hash)
define_singleton_method (Kernel)
delete_if (Set)
demodulize (String)
det (Matrix)
det (Matrix::LUPDecomposition)
det_e (Matrix)
determinant (Matrix)
determinant (Matrix::LUPDecomposition)
determinant_e (Matrix)
diagonal (Matrix)
diagonal? (Matrix)
div (Fixnum)
downcase (Symbol)
drop (Enumerator::Lazy)
drop (Enumerable)
drop_while (Enumerator::Lazy)
drop_while (Enumerable)
each (Vector)
each (Prime::PseudoPrimeGenerator)
each (Matrix)
each (Prime)
each (Prime::OldCompatibility)
each (Enumerator::GeneratorBP)
each2 (Vector)
each_char (String)
each_char (IO)
each_entry (Enumerable)
each_pair (OpenStruct)
each_prime (Integer)
each_with_index (Matrix)
each_with_index_with_optional_args_and_block (Enumerable)
each_with_object (Enumerable)
eigen (Matrix)
eigensystem (Matrix)
eigenvalue_matrix (Matrix::EigenvalueDecomposition)
eigenvalues (Matrix::EigenvalueDecomposition)
eigenvector_matrix (Matrix::EigenvalueDecomposition)
eigenvector_matrix_inv (Matrix::EigenvalueDecomposition)
eigenvectors (Matrix::EigenvalueDecomposition)
element (Matrix)
element (Vector)
elements (Vector)
elements_to_f (Matrix)
elements_to_f (Vector)
elements_to_i (Vector)
elements_to_i (Matrix)
elements_to_r (Matrix)
elements_to_r (Vector)
empty (Matrix)
empty? (Matrix)
empty? (Symbol)
end_with? (String)
entries_with_optional_arguments (Enumerable)
enum_for (Enumerator::Lazy)
eql? (Vector)
eql? (Hash)
eql? (OpenStruct)
eql? (Matrix)
eval (Binding)
even? (Integer)
expand_path_with_potential_to_path (File)
extend_relative (Backports::StdLib)
extract_options! (Array)
fdiv (Fixnum)
find_all (Enumerator::Lazy)
find_index (Enumerable)
find_index (Matrix)
first (Enumerable)
flat_map (Enumerable)
flat_map (Enumerator::Lazy)
flatten_with_optional_argument (Array)
flatten_with_optional_argument! (Array)
from_prime_division (Integer)
grep (Enumerator::Lazy)
group_by (Enumerable)
hash (Hash)
hash (Matrix)
hash (OpenStruct)
hash (Vector)
hermitian? (Matrix)
home (Dir)
identity (Matrix)
imag (Matrix)
imaginary (Matrix)
include? (Backports::StdLib::LoadedFeatures)
include? (Backports::StdLib::LoadedFeatures)
index (Matrix)
index_with_block (Array)
inherited (BasicObject)
initialize_with_optional_block (Enumerator)
inject_with_symbol (Enumerable)
inner_product (Vector)
inspect (Matrix)
inspect (Random)
inspect (Vector)
inspect (Enumerator::Lazy)
instance (Prime)
instance_exec (Kernel)
instance_method_with_additional_info (Module)
int_from_prime_division (Prime)
inv (Matrix)
inverse (Matrix)
is_array? (Backports)
keep_if (Set)
keep_if (Array)
keep_if (Hash)
l (Matrix::LUPDecomposition)
lambda? (Proc)
lambda_with_lambda_tracking (Kernel)
lazy (Enumerator::Lazy)
lazy (Enumerable)
left (Backports::Random::MT19937)
length (Symbol)
length (String)
log2 (Math)
loop_with_stop_iteration (Kernel)
lower_triangular? (Matrix)
lup (Matrix)
lup_decomposition (Matrix)
magnitude (Vector)
make_block_optional (Backports)
map (Matrix)
map (Vector)
map (Enumerator::Lazy)
map2 (Vector)
mark_as_loaded (Backports::StdLib::LoadedFeatures)
mark_as_loaded (Backports::StdLib::LoadedFeatures)
marshal_dump (Backports::Random::Implementation)
marshal_dump (Backports::Random::MT19937)
marshal_load (Backports::Random::Implementation)
marshal_load (Backports::Random::MT19937)
match (Symbol)
max_by (Enumerable)
method_with_additional_info (Kernel)
min_by (Enumerable)
minmax (Enumerable)
minmax_by (Enumerable)
minor (Matrix)
mktmpdir (Dir)
module_exec (Module)
new (Prime::Generator23)
new (Matrix)
new (Prime)
new (Enumerator::Lazy)
new (Enumerator::Yielder)
new (Backports::Random::MT19937)
new (Prime::TrialDivisionGenerator)
new (Prime::EratosthenesGenerator)
new (Matrix::LUPDecomposition)
new (Backports::Random::Implementation)
new (Enumerator::GeneratorBP)
new (Matrix::EigenvalueDecomposition)
new (Prime::PseudoPrimeGenerator)
new (Vector)
new_seed (Random)
next (Prime::PseudoPrimeGenerator)
next (Prime::Generator23)
next (Prime::TrialDivisionGenerator)
next (Prime::OldCompatibility)
next (Prime::EratosthenesGenerator)
next (Enumerable::Enumerator)
next (Symbol)
next_state (Backports::Random::MT19937)
next_to (Prime::EratosthenesSieve)
none? (Enumerable)
norm (Vector)
normal? (Matrix)
normalize (Vector)
odd? (Integer)
one? (Enumerable)
open_with_options_hash (IO)
open_with_options_hash (lib/backports/1.9.1/file/open.rb)
ord (Integer)
ord (String)
orthogonal? (Matrix)
p (Matrix::LUPDecomposition)
partition_with_new_meaning (String)
permutation (Array)
permutation? (Matrix)
pop_with_optional_argument (Array)
pred (Integer)
prepend (String)
prime? (Prime)
prime? (Integer)
prime_division (Prime)
prime_division (Integer)
primes (Prime::TrialDivision)
primes_so_far (Prime::TrialDivision)
proc_with_lambda_tracking (Kernel)
product (Array)
product_with_block (Array)
public_method (Kernel)
public_send (Kernel)
r (Vector)
rand (Backports::Random::Implementation)
random_32_bits (Backports::Random::MT19937)
random_bytes (Backports::Random::MT19937)
random_float (Backports::Random::MT19937)
random_integer (Backports::Random::MT19937)
rank (Matrix)
rank_e (Matrix)
rassoc (Hash)
real (Matrix)
real? (Matrix)
rect (Matrix)
rectangular (Matrix)
regular? (Matrix)
reject (Enumerator::Lazy)
repeated_combination (Array)
repeated_permutation (Array)
require_relative_dir (Backports)
require_with_backports (Kernel)
reverse_each (Enumerable)
reverse_merge (Hash)
reverse_merge! (Hash)
rewind (Prime::TrialDivisionGenerator)
rewind (Prime::EratosthenesGenerator)
rewind (Prime::PseudoPrimeGenerator)
rewind (Enumerable::Enumerator)
rewind (Prime::Generator23)
rindex_with_block (Array)
rotate (Array)
rotate! (Array)
round (Matrix)
round_with_digits (Float)
round_with_digits (Numeric)
round_with_digits (Integer)
row (Matrix)
row_size (Matrix)
row_vector (Matrix)
row_vectors (Matrix)
rows (Matrix)
rpartition (String)
sample (Array)
scalar (Matrix)
seed= (Backports::Random::MT19937)
select (Enumerator::Lazy)
select! (Array)
select! (Hash)
select_with_hash_return (Hash)
set_component (Vector)
set_component (Matrix)
set_element (Matrix)
set_element (Vector)
shift_with_optional_argument (Array)
shuffle (Array)
shuffle! (Array)
singleton_class (Kernel)
singular? (Matrix)
singular? (Matrix::LUPDecomposition)
size (Symbol)
size (Range)
size (File)
size (Vector)
slice_before (Enumerable)
solve (Matrix::LUPDecomposition)
sort_by! (Array)
square? (Matrix)
srand (Backports::Random::Implementation)
start_with? (String)
state_as_bignum (Backports::Random::MT19937)
stress (GC)
stress= (GC)
stringify_keys (Hash)
stringify_keys! (Hash)
succ (Prime::Generator23)
succ (Prime::TrialDivisionGenerator)
succ (Prime::EratosthenesGenerator)
succ (Prime::OldCompatibility)
succ (Symbol)
succ (Prime::PseudoPrimeGenerator)
sum (Enumerable)
suppress_verbose_warnings (Backports)
swapcase (Symbol)
symbolize_keys (Hash)
symbolize_keys! (Hash)
symmetric? (Matrix)
t (Matrix)
take (Enumerable)
take (Enumerator::Lazy)
take_while (Enumerator::Lazy)
take_while (Enumerable)
tap (Kernel)
to_a (Vector)
to_a (Matrix::EigenvalueDecomposition)
to_a (Matrix)
to_a (Matrix::LUPDecomposition)
to_a_with_optional_arguments (Enumerable)
to_ary (Matrix::EigenvalueDecomposition)
to_ary (Matrix::LUPDecomposition)
to_enum (Enumerator::Lazy)
to_h (NilClass)
to_h (Struct)
to_h (Hash)
to_h (Enumerable)
to_h (OpenStruct)
to_proc (Symbol)
to_proc_with_lambda_tracking (Method)
to_r (Complex)
to_s (Matrix)
to_s (Vector)
tr (Matrix)
trace (Matrix)
transpose (Matrix)
try (Object)
try_convert (Array)
try_convert (Hash)
try_convert (Backports)
try_convert (Regexp)
try_convert (IO)
try_convert (String)
u (Matrix::LUPDecomposition)
unbind_with_additional_info (Method)
underscore (String)
union_with_array_argument (Regexp)
uniq_with_block (Array)
uniq_with_block! (Array)
unitary? (Matrix)
upcase (Symbol)
upper_bound (Prime::PseudoPrimeGenerator)
upper_bound= (Prime::PseudoPrimeGenerator)
upper_triangular? (Matrix)
upto_with_exclusive (String)
v (Matrix::EigenvalueDecomposition)
v_inv (Matrix::EigenvalueDecomposition)
with_index (Enumerable::Enumerator)
with_object (Prime::PseudoPrimeGenerator)
write (IO)
write (Backports)
yield (Enumerator::Yielder)
zero (Matrix)
zero? (Matrix)
zip (Enumerator::Lazy)