# [−][src]Crate frank

## Traits

Fetching | frank::Fetching can be implemented for generic vectors that support Clone with 'use frank::Fetching;' It allows vector.fetch(&your_picks_vec_usize) and vector.fetch_guard(&your_picks_vec_usize). fetch is fast and fetch_guard is index guarded, won't terminate but does eprint!'s index errors and still returns computable results. |

Ranking | frank::Ranking can be used with any generic vector that implements PartialOrd and Clone, and will return rankings from "greatest = 0" to least. just 'use frank::Ranking' for bolt on vector ranking functions like 'let myranks = myvector.rank();' Useful for non-parametric statistics like the difference between vec![82, 65, 78, 69, 68].rank() and vec!["r","a","n","k","ed"].rank() |

## Functions

example_code | |

fetch_fast | fetch_fast has no slow branching if-then checks on index values, it just returns what it is asked to and terminates program if out of index. |

fetch_guard | vector.fetch(&my_borrowed_usize_list) will return a vector of your usized picks. Error tollerant and useful for user guided selective statistics, computation of quatriles and building custom scrolling levels out of 8 bit character bitmaps from selections that previously caused the most player deaths (maybe?)
use one of two ways: genericvector.fetch(&vector_usize_index_picks) or from the function with fetch_guard(&genericvector, &your_usize_picklist)
#Example |

imean | fn imean(vector) takes generic vector primitives and calculates a every bit accurate (if not especially fast) integer mean for long vector primitives 64 bits or smaller. Potentially useful for signal processing where the signal could be obscured by sig. digit loss in f64 values. Rounds half and up away from zero and less than half towards zero (-9/4-> -2, 9/2 -> 4). Not recommended for 128bit primitives unless addition overflow in 128bits can always be avoided. |

rank_count_greater | rank_count_greater(&borrowedboxedtea) borrows a generic vector and returns a usize vector list of the count of greater items for each item. Large items get small ranks, small items get large ranks. The greatest value in a list scores a zero rank, while the item with 30 superiors earns rank 30 - based on the
ranking system described by Wassily Hoeffding in 1947. Note: a tie for second place means there can be no third place rank but still allows a fourth place award unless there were multiple second place times. |

rank_count_lesser | vector.rank_count_lesser() borrows a generic vector and returns a usize vector list of the count of lesser items in the generic vector. Small values score small ranks, large values score large ranks. The smallest value in a list scores a zero rank, based on a ranking system described by Wassily Hoeffding in 1947. Note: a tie for second place means there can be no third place rank but still allows a fourth place award. Useful for nonparametric statistics, say for comparison of 5k race times... which reminds me of a joke. So twin photons, a zippy electron and a massive proton all have a race. The proton is positive he'll finish last, and of course the photon twins win because they travel light. The ranks of such a race would likely be: 0,0,2,3 or 0,0,2,2. |

rank_dense_greater | rank_dense_greater(&generictea) returns dense ranks where large values get smaller ranks, and small values get larger ranks. Dense Ranks Explained: If three javelin throwers win in a tie should they be awarded three third place metals and no first place metals, or three first places? And would the second place and third place metals get be awarded to other competitors? If scored with dense ranks, the answer is yes there are three first places, and yes there is a second and third place rank, no ranks get skipped. Uneven steps between clusters can hatch data illusions, and dense ranks always have predictable steps. That said, dense ranks do lose cluster size information. |

rank_dense_lesser | rank_dense_lesser(&generictea) returns dense ranks where large values get larger ranks, and small values get smaller ranks. Smallest value takes a zero rank. Dense Ranks Explained: If three racers win in a time tie should they be awarded three third place metals and no first place metals, or three first places? And would the second place and third place metals get be awarded to other competitors? If scored with dense ranks, the answer is yes there are three first places, and yes there is a second and third place rank, no ranks get skipped. Uneven steps between clusters can hatch data illusions, and dense ranks always have predictable steps. That said, dense ranks do lose cluster size information. |

rrank | rrank() follows the R Language rank() convention with the result as Vec |

sequence_linear_sum | fn sequence_linear_sum(usize_n) computes the total of a range from 1 to usize_n. Overflow possible for large n, like 6074000999 with 64bit usize. |

sequence_square_sum | fn seq_sum_of_squares(usize_n) uses discrete calculus to compute the sum of 1^2 + 2^2 + 3^2... n^2 --> (2n^3 + 3n^2 + n)/6 without the repetition of adding each element by way of a tiny bit of discrete calculus. Overflow possible for large n like 3810776 for 64bit usize. useful for certain comparisions, or do twice and subtract for a partial sum of squares between say 23901^2 and 24824^2. |