Update docs/readme

Author: Genbox

Docs/BinarySearch.xlsx

@@ -1,19 +1,26 @@
 # FastData
 
-[![NuGet](https://img.shields.io/nuget/v/Genbox.FastData.svg?style=flat-square&label=nuget)](https://www.nuget.org/packages/Genbox.FastData/)
 [![License](https://img.shields.io/github/license/Genbox/FastData)](https://github.com/Genbox/FastData/blob/master/LICENSE.txt)
 
+![Docs/FastData.png](Docs/FastData.png)
+
 ## Description
 
 FastData is a code generator that analyzes your data and creates high-performance, read-only lookup data structures for
 static data. It can output the data structures
 in many different languages (C#, C++, Rust, etc.), ready for inclusion in your project with zero dependencies.
 
+## Download
+
+[![C# library](https://img.shields.io/nuget/v/Genbox.FastData.Generator.CSharp.svg?style=flat-square&label=nuget)](https://www.nuget.org/packages/Genbox.FastData.Generator.CSharp/)
+[![.NET Tool](https://img.shields.io/nuget/v/Genbox.FastData.Cli.svg?style=flat-square&label=nuget)](https://www.nuget.org/packages/Genbox.FastData.Cli/)
+
+
 ## Use case
 
 Imagine a scenario where you have a predefined list of words (e.g., dog breeds) and need to check whether a specific dog
 breed exists in the set.
-Usually you create an array and look up the value. However, this is far from optimal and is missing a few optimizations.
+Usually you create an array and look up the value. However, this is far from optimal and is lacks several optimizations.
 
 ```csharp
 string[] breeds = ["Labrador", "German Shepherd", "Golden Retriever"];
@@ -22,7 +29,7 @@ if (breeds.Contains("Beagle"))
     Console.WriteLine("It contains Beagle");
 ```
 
-We can do better by analyzing the dataset and generating a data structure optimized for the data.
+We can do better by analyzing the dataset and generating an optimized data structure.
 
 1. Create a file `Dogs.txt` with the following contents:
 
@@ -32,7 +39,7 @@ German Shepherd
 Golden Retriever
 ```
 
-2. Run `FastData csharp Dogs.txt`. It produces the output:
+2. Run `FastData csharp Dogs.txt`. It produces the following output:
 
 ```csharp
 internal static class Dogs
@@ -62,8 +69,8 @@ internal static class Dogs
 Benefits of the generated code:
 
 - **Fast Early Exit:** A bitmap of string lengths allows early termination for out-of-range values.
-- **Efficient Lookups:** A switch-based data structure. It uses more advanced structures for larger data sets.
-- **Additional Metadata:** Provides item count and minimum/maximum string length.
+- **Efficient Lookups:** A switch-based data structure which is fast for small datasets.
+- **Additional Metadata:** Provides item count and other useful properties.
 
 A benchmark of the array versus our generated structure really illustrates the difference. It is 13x faster.
 
@@ -82,91 +89,71 @@ There are several ways of running FastData. See the sections below for details.
 2. Create a file with an item per line
 3. Run `FastData csharp File.txt`
 
-### Using it in a C# application
+### Using the .NET Source Generator
 
-1. Add the `Genbox.FastData.Generator.CSharp` nuget package to your project.
-2. Use the `FastDataGenerator.TryGenerate()` method. Give it your data as an array.
+1. Add the `Genbox.FastData.SourceGenerator` package to your project
+2. Add `FastDataAttribute` as an assembly level attribute.
 
 ```csharp
+using Genbox.FastData.SourceGenerator;
+
+[assembly: FastData<string>("Dogs", ["Labrador", "German Shepherd", "Golden Retriever"])]
+
 internal static class Program
 {
     private static void Main()
     {
-        FastDataConfig config = new FastDataConfig();
-        config.StringComparison = StringComparison.OrdinalIgnoreCase;
-
-        CSharpCodeGenerator generator = new CSharpCodeGenerator(new CSharpGeneratorConfig("Dogs"));
-
-        if (!FastDataGenerator.TryGenerate(["Labrador", "German Shepherd", "Golden Retriever"], config, generator, out string? source))
-            Console.WriteLine("Failed to generate source code");
-
-        Console.WriteLine(source);
+        Console.WriteLine(Dogs.Contains("Labrador"));
+        Console.WriteLine(Dogs.Contains("Beagle"));
     }
 }
 ```
 
-### Using the .NET Source Generator
+### Using it as a C# library
 
-1. Add the `Genbox.FastData.SourceGenerator` package to your project
-2. Add `FastDataAttribute` as an assembly level attribute.
+1. Add the `Genbox.FastData.Generator.CSharp` NuGet package to your project.
+2. Use the `FastDataGenerator.TryGenerate()` method. Give it your data as an array.
 
 ```csharp
-using Genbox.FastData.SourceGenerator;
-
-[assembly: FastData<string>("Dogs", ["Labrador", "German Shepherd", "Golden Retriever"])]
-
 internal static class Program
 {
     private static void Main()
     {
-        Console.WriteLine(Dogs.Contains("Labrador"));
-        Console.WriteLine(Dogs.Contains("Beagle"));
+        FastDataConfig config = new FastDataConfig();
+
+        CSharpCodeGenerator generator = new CSharpCodeGenerator(new CSharpGeneratorConfig("Dogs"));
+
+        if (!FastDataGenerator.TryGenerate(["Labrador", "German Shepherd", "Golden Retriever"], config, generator, out string? source))
+            Console.WriteLine("Failed to generate source code");
+
+        Console.WriteLine(source);
     }
 }
 ```
 
-Whenever you change the array, it automatically generates the new source code and includes it in your project.
+Whenever you change the array, it automatically generates the new source code.
 
 ## Features
 
 - **Data Analysis:** Optimizes the structure based on the inherent properties of the dataset.
-- **Multiple Indexing Structures:** FastData automatically chooses the best structure for your data.
+- **Multiple Structures:** FastData automatically chooses the best data structure for your data.
+- **Fast hashing:** String lookups are fast due to a fast string hash function
 
 It supports several output programming languages.
 
-* C# output: `fastdata csharp <input-file>`
-* C++ output: `fastdata cplusplus <input-file>`
-* Rust output: `fastdata rust <input-file>`
+* C#: `FastData csharp <input-file>`
+* C++: `FastData cplusplus <input-file>`
+* Rust: `FastData rust <input-file>`
 
-Each output language has different settings. Type `fastdata <lang> --help` to see the options.
+Each output language has different settings. Type `FastData <lang> --help` to see the options.
 
 ### Data structures
 
 By default, FastData chooses the optimal data structure for your data, but you can also set it manually with
-`fastdata -s <type>`. See the details of each structure type below.
-
-#### SingleValue
+`FastData -s <type>`. See the details of each structure type below.
 
-* Memory: Low
-* Latency: Low
-* Complexity: O(1)
-
-This data structure only supports a single value. It is much faster than an array with a single item and has no overhead
-associated with it.
-FastData always selects this data structure whenever your dataset only contains one item.
-
-#### Conditional
-
-* Memory: Low
-* Latency: Low
-* Complexity: O(n)
-
-This data structure relies on built-in logic in the programming language. It produces if/switch statements which
-ultimately become machine instructions on the CPU, rather than data
-that resides in memory.
-Latency is therefore incredibly low, but the higher number of instructions bloat the assembly, and at a certain point it
-becomes more efficient to have
-the data reside in memory.
+#### Auto
+This is the default option. It autoselects the best data structure based on the number of items you provide.
 
 #### Array
 
@@ -190,26 +177,20 @@ overhead at runtime. Each lookup
 has a higher latency than a simple array, but once the dataset gets to a few hundred items, it beats the array due to a
 lower complexity.
 
-#### EytzingerSearch
-
-* Memory: Low
-* Latency: Medium
-* Complexity: O(n*log(n))
-
-This data structure sorts data using an Eytzinger layout. It has better cache-locality than binary search. Under some
-circumstances it has better performance.
-
-#### KeyLength
+#### Conditional
 
 * Memory: Low
 * Latency: Low
-* Complexity: O(1)
+* Complexity: O(n)
 
-This data structure only works on strings, but it indexes them after their length, rather than a hash. In the case all
-the strings have unique lengths, the
-data structure further optimizes for latency.
+This data structure relies on built-in logic in the programming language. It produces if/switch statements which
+ultimately become machine instructions on the CPU, rather than data
+that resides in memory.
+Latency is therefore incredibly low, but the higher number of instructions bloat the assembly, and at a certain point it
+becomes more efficient to have
+the data reside in memory.
 
-#### HashSetChain
+#### HashSet
 
 * Memory: Medium
 * Latency: Medium
@@ -219,35 +200,6 @@ This data structure is based on a hash table with separate chaining collision re
 buckets to stay cache coherent, but it also uses more
 memory since it needs to keep track of indices.
 
-#### HashSetLinear
-
-* Memory: Medium
-* Latency: Medium
-* Complexity: O(1)
-
-This data structure is also a hash table, but with linear collision resolution.
-
-#### PerfectHashBruteForce
-
-* Memory: Low
-* Latency: Low
-* Complexity: O(1)
-
-This data structure tries to create a perfect hash for the dataset. It does so by brute-forcing a seed for a simple hash
-function
-until it hits the right combination. If the dataset is small enough, it can even produce a minimal perfect hash.
-
-#### PerfectHashGPerf
-
-* Memory: Low
-* Latency: Low
-* Complexity: O(1)
-
-This data structure uses the same algorithm as gperf to derive a perfect hash. It uses Richard J. Cichelli's method for
-creating an associative table,
-which is augmented using alpha increments to resolve collisions. It only works on strings, but it is great for
-medium-sized datasets.
-
 ## How does it work?
 
 The idea behind the project is to generate a data-dependent optimized data structure for read-only lookup. When data is
@@ -258,7 +210,7 @@ of different data structures, indexing, and comparison methods that are tailor-b
 
 There are many benefits gained from generating data structures at compile time:
 
-* Enables analysis the data
+* Enables otherwise time-consuming data analysis
 * Zero runtime overhead
 * No defensive copying of data (takes time and needs double the memory)
 * No virtual dispatching (virtual method calls & inheritance)
@@ -276,19 +228,6 @@ FastData uses advanced data analysis techniques to generate optimized data struc
 It uses the analysis to create so-called early-exits, which are fast `O(1)` checks on your input before doing any `O(n)`
 checks on the actual dataset.
 
-#### Hash function generators
-
-Hash functions come in many flavors. Some are designed for low latency, some for throughput, others for low collision
-rate.
-Programming language runtimes come with a hash function that is a tradeoff between these parameters. FastData builds a
-hash function specifically tailored to the dataset.
-It has support for several techniques:
-
-1. **Default:** If no technique is selected, FastData uses a hash function by Daniel Bernstein (DJB2)
-2. **Brute force:** It spends some time on trying increasingly stronger hash functions
-3. **Heuristic:** It tries to build a hash function that selects for entropy in strings
-4. **Genetic algorithm:** It uses machine learning to evolve a hash function that matches the data effectively
-
 ## Best practices
 
 * Put the most often queried items first in the input data. It can speed up query speed for some data structures.
@@ -300,4 +239,4 @@ It has support for several techniques:
     * Frozen comes with considerable runtime overhead
     * Frozen is only available in .NET 8.0+
     * Frozen only provides a few of the optimizations provided in FastData
-    * Frozen is only available in C#. FastData can produce data structures in many langauges.
+    * Frozen is only available in C#. FastData can produce data structures in many languages.