approximate human readable time
Estimate the reading duration of blog posts and articles. Enhance the user experience by providing readers with an insightful glance at the approximate time required to consume your content.
Reports the approximate time ago in words from a specific past date
A multi-lingual component for React that renders the approximate time ago in words from a specific past date using an HTML5 time element
Approximate (fast) current UNIX time.
Converts numbers into a more human-friendly format, similar to `ls`'s `--human-readable` flag (`ls -lh`) or Stack Overflow's reputation numbers. For example, 123456 becomes '123k'.
Ukkonens approximate string matching algorithm for finding edit distance similar to Levenshtein
javascript implementation of Dunning's T-Digest for streaming quantile approximation
TypeScript definitions for approximate-number
A range lets users choose an approximate value on a slider.
A Cypress plugin for reporting individual command timings
A WeakMap shim for Node.js and browsers
A plugin for Babel 6 supports extending from builtin types based on static analysis.
A high-performance string compression library
Programmatic access to information about the AXObject Model
Format validation for Ajv v7+
DiskANN/Vamana — SSD-friendly billion-scale approximate nearest neighbor search with product quantization
A calculator for humanity’s peculiar conventions of time.
TypeScript definitions for d3-time
TypeScript definitions for geoip-lite
Calculates the size of Javascript object.
Time zone support for date-fns v3 with the Intl API
date-fns timezone utils
Decrease your start up time and RAM memory consumption by an application via splitting JS bundle by components and navigation routes
This gem contains command-line utility for solving 0/1 knapsack problem using branch-and-bound method, dynamic programming, simple heuristic (weight/price) and fully polynomial time approximation scheme. It can measure CPU and wall-clock time spent by solving a problem, compute relative error of the result and generate graphs from those values.
Hanny is a Hash-based Approximate Nearest Neighbor (ANN) search library in Ruby. Hash-based ANN converts vector data into binary codes and builds a hash table by using the binary codes as hash keys. To build the hash table, Hanny uses Locality Sensitive Hashing (LSH) of approximating cosine similarity. It is known that if the code length is sufficiently long (ex. greater than 128-bit), LSH can obtain high search performance. In the experiment, Hanny achieved about twenty times faster search speed than the brute-force search by Euclidean distance.
This gem provides a casually secure (you will never beat the pros) implementation of the One-Time Pad encryption technique, using multiple substitution cyphers suitable for educational and practical use. Knowing the code, you still have approximately 4.3 billion randon seeds to choose from to decode an unknown message.
With the happy proliferation of TDD, test suites are getting massive, and developer efficiency is dwindling as we wait for our tests to pass. There is a big tradeoff between making unit test more integrationish (and therefore more reliable) vs. making them very mocky, unity and fast. Mockumentary is a library for the later. It inspects the ActiveRecord universe and makes a series of AR mockeries that approximate model without hitting the database, or making any assertions. The assertions, they are still part of the developers job. Mocumentary has two types of AR mockeries: One is used within the Rails universe. It uses introspection to derive association and field information. The second is a static copy built from the first. This static version can be used outside the Rails test universe in a suite faster than the speed of Rails environment load time. Mocking isn't for everyone, so test-drive responsibly.
Noisy sensor data, approximations in the equations that describe the system evolution, and external factors that are not accounted for all place limits on how well it is possible to determine the system's state. The Kalman filter deals effectively with the uncertainty due to noisy sensor data and to some extent also with random external factors. The Kalman filter produces an estimate of the state of the system as an average of the system's predicted state and of the new measurement using a weighted average. The purpose of the weights is that values with better (i.e., smaller) estimated uncertainty are "trusted" more. The weights are calculated from the covariance, a measure of the estimated uncertainty of the prediction of the system's state. The result of the weighted average is a new state estimate that lies between the predicted and measured state, and has a better estimated uncertainty than either alone. This process is repeated at every time step, with the new estimate and its covariance informing the prediction used in the following iteration. This means that the Kalman filter works recursively and requires only the last "best guess", rather than the entire history, of a system's state to calculate a new state.