[package]
name = "frank"
version = "0.1.3"
authors = ["dustan doud cancellogic.com"]
edition = "2018"

description = "Frank - Fetch and Rank adds bolt-on generic vector ranking and fetching features.  Just use and let resultvec = vector.rank() or resultvec = vector.fetch(&my_picks_vec).  Fun extras: sequence_sum_of_squares (by calculus, not iteration), integer means, dense_ranking. "   
license = "MIT OR Apache-2.0"
keywords = ["rank", "fetch", "generic", "vector", "Hoeffding"]

[profile.dev]
opt-level = 3

[profile.release]
opt-level = 3

[description]
 # Frank - Rank and Fetch adds "bolt-on" generic vector ranking (R lang style, Hoeffding style and Dense rank) and fetching, and a few extras.  I made this crate out of code I use, in part to learn rust & rustdoc and also as a gift to the rust community.     
 # vector.rank() yields a count of values that are larger than the value at each vector index, as decribed by Wassily Hoeffding in ~1947.  Ranking and fetching works with vectors and should work with borrowed generic boxed teas.  
 # You can vector.rank_count_lesser(), rank_count_greater(&boxed_tea) or vector.rrank().   Rank_dense_greater(&BoxedTea) provides dense ranks, a million a,b or c's would result in a million 0,1 or 2's - not values that represent how many a's b's and c's.  
 # vector.fetch(&picks) is intended for user specified subsampling of generic data.  If ranking is a slice of chocolate cake, then fetching is a plastic fork.  Once you have a rank, someone always wants a top ten list or quatrile.
 # Extras: 
 #   vector.fetch_guards(&picks) is vector.fetch() but tolerates human error in pick lists.  Returns only the computable results.  eprints misses with weak debug hints.    
 #   fn imean(vector) - generic integer mean calculation for primitive vector types.  Optimized for accurate results before speed, useful for small digital signals that could be lost in a floating point conversion. 
 #   fn sequence_square_sum(n) - calculates 1+ 2^2 + 3^2 ... up to n^2.  Computes by near instant discrete usize calculus, (overflows 32bit at n=2343 | 64bit to n=3810776).   
 #   fn sequence_linear_sum(n) - calculates 1+2+3+4... up to n.  Computes by near instant discrete usize calculus (overflows at 32bit n=92681 | 64bit n=6074000999)
 #   I included the sequence sums because its something that matchs the statistics feel of the rest of the crate.. and I use them.
[dependencies]
num-traits = "0.2.6"