react-native-vroom-chart 0.12.0 → 0.13.0

package/cpp/_core_src/price_format.cpp

@@ -2,6 +2,7 @@
 
 #include <algorithm>
 #include <cmath>
+#include <cstddef>
 #include <cstdio>
 
 namespace vroom {
@@ -15,6 +16,38 @@ constexpr size_t kPlainCap = 340;
 constexpr char kGroupSeparator = ',';
 constexpr int kGroupSize = 3;
 
+constexpr double kMillion = 1e6;
+constexpr double kBillion = 1e9;
+constexpr double kTrillion = 1e12;
+
+double compact_divisor(CompactScale scale) {
+    switch (scale) {
+        case CompactScale::Million:  return kMillion;
+        case CompactScale::Billion:  return kBillion;
+        case CompactScale::Trillion: return kTrillion;
+        case CompactScale::None:     return 1.0;
+    }
+    return 1.0;
+}
+
+char compact_suffix(CompactScale scale) {
+    switch (scale) {
+        case CompactScale::Million:  return 'M';
+        case CompactScale::Billion:  return 'B';
+        case CompactScale::Trillion: return 'T';
+        case CompactScale::None:     return '\0';
+    }
+    return '\0';
+}
+
+CompactScale compact_scale_for(double reference) {
+    const double r = std::fabs(reference);
+    if (!std::isfinite(r) || r < kMillion) return CompactScale::None;
+    if (r >= kTrillion) return CompactScale::Trillion;
+    if (r >= kBillion) return CompactScale::Billion;
+    return CompactScale::Million;
+}
+
 }  // namespace
 
 int significant_decimals(double reference) {
@@ -28,7 +61,8 @@ int significant_decimals(double reference) {
 }
 
 PriceFormat price_format_for(double reference) {
-    return PriceFormat{significant_decimals(reference), true};
+    return PriceFormat{significant_decimals(reference), true,
+                       compact_scale_for(reference)};
 }
 
 int price_decimals(double interval) {
@@ -40,8 +74,13 @@ int price_decimals(double interval) {
 }
 
 PriceFormat with_tick_guard(const PriceFormat& fmt, double interval) {
-    return PriceFormat{std::max(fmt.decimals, price_decimals(interval)),
-                       fmt.group};
+    const double divisor = compact_divisor(fmt.compact);
+    const double display_interval =
+        (divisor != 1.0 && interval > 0.0 && std::isfinite(interval))
+            ? interval / divisor
+            : interval;
+    return PriceFormat{std::max(fmt.decimals, price_decimals(display_interval)),
+                       fmt.group, fmt.compact};
 }
 
 void format_price(char* buf, size_t buf_size, double price,
@@ -49,11 +88,23 @@ void format_price(char* buf, size_t buf_size, double price,
     if (!buf || buf_size == 0) return;
     const int decimals = std::clamp(fmt.decimals, 0, kPriceMaxDecimals);
 
+    const double divisor = compact_divisor(fmt.compact);
+    const double display = (divisor != 1.0) ? price / divisor : price;
+
     char plain[kPlainCap];
-    if (std::snprintf(plain, sizeof(plain), "%.*f", decimals, price) < 0) {
+    if (std::snprintf(plain, sizeof(plain), "%.*f", decimals, display) < 0) {
         buf[0] = '\0';
         return;
     }
+
+    const char suffix = compact_suffix(fmt.compact);
+    if (suffix != '\0') {
+        // Compact form is already short; grouping would only fire if a tick
+        // wandered across a suffix boundary (1000.00M). Skip it.
+        std::snprintf(buf, buf_size, "%s%c", plain, suffix);
+        return;
+    }
+
     if (!fmt.group) {
         std::snprintf(buf, buf_size, "%s", plain);
         return;

package/cpp/_core_src/price_format.h

@@ -13,6 +13,16 @@
 //   0.023397  -> 6 decimals   0.023397
 //   80285.20  -> 2 decimals   80,285.20   (floor)
 //   2513.92   -> 2 decimals   2,513.92    (floor)
+//   1.59e6    -> compact      1.59M
+//   3.219e7   -> compact      32.19M
+//   3.454e10  -> compact      34.54B
+//   1.2e12    -> compact      1.20T
+//
+// Past a million the integer digits eat the axis, so the format switches to a
+// suffix (M / B / T) with two decimal places. The suffix is keyed off the
+// asset's own price, not each tick, so every label on a market-cap chart
+// shares a column and a zoomed-in 32.1M–32.2M range does not mix "32.15M"
+// with "32,150,000.00".
 //
 // The reference is the asset's own price, not the visible range, so the
 // precision holds steady while the user pans and zooms. A range-derived count
@@ -32,18 +42,31 @@ namespace vroom {
 inline constexpr int kPriceSigDigits = 5;
 
 // Prices at or above ~1 unit read as currency, where fewer than two decimals
-// looks broken (a "$84,000" axis next to a "$80,285.20" last price).
+// looks broken (a "$84,000" axis next to a "$80,285.20" last price). Compact
+// suffixes use the same floor: "32.19M", not "32.2M".
 inline constexpr int kPriceMinDecimals = 2;
 
 // Past this the digits are noise, and %.*f starts printing the binary
 // representation's tail rather than anything the feed meant.
 inline constexpr int kPriceMaxDecimals = 12;
 
+// Compact suffix for assets priced in the millions and up. Keyed off the
+// reference, then applied to every label so the column stays uniform. Nothing
+// below a million is abbreviated — no K.
+enum class CompactScale {
+    None,
+    Million,    // |ref| >= 1e6
+    Billion,    // |ref| >= 1e9
+    Trillion,   // |ref| >= 1e12
+};
+
 // How to render a price. `group` inserts thousands separators, which only ever
-// affects the integer part.
+// affects the integer part of a non-compact format. `compact` scales the value
+// and appends M / B / T; grouping is skipped in that path.
 struct PriceFormat {
-    int  decimals = kPriceMinDecimals;
-    bool group = true;
+    int          decimals = kPriceMinDecimals;
+    bool         group = true;
+    CompactScale compact = CompactScale::None;
 };
 
 // Decimals giving kPriceSigDigits significant digits for an asset priced around
@@ -51,7 +74,8 @@ struct PriceFormat {
 // non-finite reference falls back to the floor.
 int significant_decimals(double reference);
 
-// The format for an asset priced around `reference`.
+// The format for an asset priced around `reference`, including the compact
+// suffix when |reference| is at least a million.
 PriceFormat price_format_for(double reference);
 
 // Decimal places needed so adjacent ticks `interval` apart don't collapse to
@@ -60,6 +84,9 @@ int price_decimals(double interval);
 
 // `fmt` raised, if need be, so ticks `interval` apart stay distinct. The asset's
 // precision is the floor; only a zoom deeper than that precision adds to it.
+// `interval` is in the data's units; when `fmt` is compact the guard converts
+// it into display units (interval / 1e6 for millions, etc.) so a 1,000-wide
+// step on a 32M chart still gets enough decimals to print as 32.192M vs 32.193M.
 PriceFormat with_tick_guard(const PriceFormat& fmt, double interval);
 
 // Writes `price` into `buf` per `fmt`, truncating rather than overrunning.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "react-native-vroom-chart",
-  "version": "0.12.0",
+  "version": "0.13.0",
   "description": "Mobile-first Skia candlestick chart for React Native",
   "license": "MIT",
   "author": "Darion Welch",