Merge pull request #9 from QuState/update-readme-again

Update README.md

README.md

@@ -12,8 +12,8 @@ including [RustFFT](https://crates.io/crates/rustfft/).
 
 ## Features
 
-- Performance on par with FFTW and far exceeding other Rust implementations
 - Simple implementation using a single, general-purpose FFT algorithm
+- Performance on par with other Rust FFT implementations
 - Zero `unsafe` code
 - Takes advantage of latest CPU features up to and including AVX-512, but performs well even without them
 - Optional parallelization of some steps to 2 threads (with even more planned)
@@ -50,10 +50,9 @@ We also use the Cache-Optimal Bit Reveral
 Algorithm ([COBRA](https://csaws.cs.technion.ac.il/~itai/Courses/Cache/bit.pdf))
 on large datasets and optionally run it on 2 parallel threads, accelerating it even further.
 
-All of this combined results in a fast and efficient FFT implementation that surpasses the performance of existing Rust
-FFT crates,
-including [RustFFT](https://crates.io/crates/rustfft/) on large inputs and while using significantly
-less memory.
+All of this combined results in a fast and efficient FFT implementation competitive with
+the performance of existing Rust FFT crates,
+including [RustFFT](https://crates.io/crates/rustfft/), while using significantly less memory.
 
 ## Quickstart
 
@@ -123,17 +122,17 @@ PhastFT is licensed under MIT or Apache 2.0 license, at your option.
 ## PhastFT vs RustFFT
 
 [RustFFT](https://crates.io/crates/rustfft/) is another excellent FFT implementation in pure Rust.
-RustFFT and PhastFT are optimized for different workloads.
-
-RustFFT performs best on small inputs that fit entirely into the L2 cache,
-while PhastFT is optimized for large input sizes common in scientific computing.
-
-PhastFT also uses 2x less memory, which is important for processing large datasets.
+RustFFT and PhastFT make different trade-offs.
 
 RustFFT made the choice to work on stable Rust compiler at the cost of `unsafe` code,
 while PhastFT contains no `unsafe` blocks but requires a nightly build of Rust compiler
 to access the Portable SIMD API.
 
+RustFFT implements multiple FFT algorithms and tries to pick the best one depending on the workload,
+while PhastFT has a single FFT implementation and still achieves competitive performance.
+
+PhastFT uses 2x less memory than RustFFT, which is important for processing large datasets.
+
 ## What's with the name?
 
 The name, **PhastFT**, is derived from the implementation of the