JavaScript numeric array implemented using an integer
Validates if a value is an integer array.
Flatten nested arrays
64-bit big-endian signed integer-to-string conversion
Pure-JS printf
Fast JavaScript array sorting by implementing Python's Timsort algorithm
Compile ES2015 unicode string and number literals to ES5
ES2015 (ES6) Number.isInteger polyfill
Rearrange array elements by index array
Validates if a value is an integer.
Default array settings.
A [ponyfill](https://ponyfill.com) for `Buffer.from`, uses native implementation if available.
Deep comparison of 2 instances for should.js
Support for representing 64-bit integers in JavaScript
A polyfill for Array.prototype.flat and Array.prototype.flatMap
Validates if a value is a nonnegative integer array.
Generate a random integer
Maintain and search through a sorted array using some low level functions
Asynchronous iterator function for parallel processing.
Randomize the order of the elements in a given array.
Find [nd-]array min/max values
ES6 Array.find ponyfill. Return the first array element which satisfies a testing function.
Array#filter for older browsers.
Packs an array-of-arrays into a single ndarray
Ruby/CArray is an extension library for the multi-dimensional numerical array class. The name "CArray" comes from the meaning of a wrapper to a numerical array handled by the C language. CArray stores integers or floating-point numbers in memory block and treats them collectively to ensure efficient performance. Therefore, Ruby/CArray is suitable for numerical computation and data analysis.
A very simple gem that adds some methods to some Ruby standard classes, e.g. <array>.include_any?, <array>.delete_random, etc. Simply require the gem ( require "more_ruby" ) and the additional methods will be available. # New instance methods # ## Array :all_instance_of?, :all_kind_of?, :av, :delete_random, :include_any?, :insert_flat, :mean, :modulo_fetch, :peach, :random, :random_index, :random_insert, :random_move, :stringify_all_values_deep, :sum, :wrap_fetch ## Float :format_with_thousands_delimiter, :signif ## Hash :all_keys, :all_values, :delete_random, :peach, :random_key, :random_pair, :random_value, :remove_empty_fields, :sort_deep, :stringify_all_values_deep, :strip_hash_of_keys, :to_a_deep, :to_xml ## Integer :digit_count, :format_with_thousands_delimiter, :num_to_letter, :signif ## NilClass :empty? ## Numeric :format_with_thousands_delimiter ## String :append, :camelcase, :camelcase_to_snakecase, :capitalize_all, :capitalize_first_letter_only, :escape, :escape_whitespace, :extract_values_from_xml_string, :formatted_number, :index_of_last_capital, :invert_case, :is_hex?, :is_integer?, :join, :pascalcase, :prefix_lines, :random_case, :snakecase, :snakecase_and_downcase, :to_bool, :unindent ## Time :is_after?, :is_before?, :is_within?, :remove_subseconds # New singleton methods # ## FalseClass :maybe?, :random ## File :basename_no_ext ## TrueClass :maybe?, :random
# Procer **NOTE: Experimental. Use it to experience what a default `to_proc` could have been. For production code, I recommend an explicit transformation, like the one provided by the gem `jgomo3-func`**. A reasonable good default `to_proc` method for all objects. Install with: ``` gem install procer ``` When you require Procer, all objects will have a default `to_proc` method which will try to call one of the following methods, in the given order: - `call` - `[]` - `===` Many methods which receive a block, can benefit greatly from this because you can now pass an object to perform the block role. Think of the Enumerable module and all its methods. Many objects define `===`, but not `to_proc`. So they will be nicely usable in a `case/when` expression, but not in other contexts. This is the case of classes and ranges, which you can use in `case/when` expressions, but they don't define `to_proc`. Now they do define `to_proc` so they are useful in those contexts. Examples: ```ruby require 'procer' [1, 2, '3', '4', 5, 6].filter(&Numeric) # => [1, 2, 5, 6] [-10, 100, -2, 3, 20, -33].filter(&(0..50)) # => [3, 20] ``` Also, Hashes already implement `to_proc` and that is useful with Enumerator. We can use it as a transformation table with `map`: ```ruby table = { 1 => 'one', 2 => 'two', 3 => 'three' } [3, 1, 2].map(&table) # => ['three, 'one, 'two'] ``` Sadly, Arrays, even when they have the same interface as hashes as a function of indices, don't implement `to_proc` and so they can't be used in the same way. Until now. ```ruby table = ['zero', 'one', 'two'] [2, 0, 1].map(&table) # => ['two', 'zero', 'one'] ``` Alternatively, you could have used `values_at`: ```ruby table.values_at([3, 1, 2]) # In the Hash example table.values_at([2, 0, 1]) # In the Array example ``` But the map solution is more generic and `table` can be anything that implements `to_proc` and not something that necessarily implements `values_at`. Notice that if the object implements `[]` that will triumph over `===`. It was unexpected when I tried to use Integers as the object, as they implement `[]` as a way to access their binary form: ```ruby 5 # b101 [5[2], 5[1], 5[0]] # [1, 0, 1] ``` So the proc will work like that: ```ruby [2, 4, 5].map(&5) # Actual => [1, 0, 0] # I was expecting => [false, false, true] ```