chore: return helper functions for data scaling and sampling

Author: exzos

example/src/App.tsx

@@ -1,14 +1,17 @@
 import { useCallback, useEffect, useState } from 'react';
-import { View, StyleSheet, ScrollView } from 'react-native';
+
+import { ScrollView, StyleSheet, Text, View } from 'react-native';
 import { computeAmplitude } from 'react-native-audio-analyzer';
+import { robustScale, sample, scale, trimmedScale } from '../../src/helpers';
 
-export default function Index() {
+export default function App() {
   const [data, setData] = useState<number[]>([]);
+
   const run = useCallback(async () => {
     try {
       const result = computeAmplitude(
         '/data/data/audioanalyzer.example/files/sample.mp3',
-        1000
+        100
       );
       setData(result);
     } catch (raw) {
@@ -21,29 +24,80 @@ export default function Index() {
     run();
   }, [run]);
 
+  const results = [
+    {
+      title: 'Original:',
+      data: data.map((value, index) => (
+        <View key={index} style={[styles.item, { height: value * 100 }]} />
+      )),
+    },
+    {
+      title: 'Trimmed scale:',
+      data: trimmedScale(data, 0, 1).map((value, index) => (
+        <View key={index} style={[styles.item, { height: value * 100 }]} />
+      )),
+    },
+    {
+      title: 'Robust scale:',
+      data: robustScale(data, 0, 1).map((value, index) => (
+        <View key={index} style={[styles.item, { height: value * 100 }]} />
+      )),
+    },
+    {
+      title: 'Scale + sample:',
+      data: scale(sample(data, 35)).map((value, index) => (
+        <View key={index} style={[styles.item, { height: value * 100 }]} />
+      )),
+    },
+    {
+      title: 'Scale:',
+      data: scale(data).map((value, index) => (
+        <View key={index} style={[styles.item, { height: value * 100 }]} />
+      )),
+    },
+  ];
+
   return (
-    <ScrollView horizontal contentContainerStyle={styles.root}>
-      <View style={styles.container}>
-        {data.map((item, index) => (
-          <View key={index} style={[styles.item, { height: 500 * item }]} />
+    <View style={styles.container}>
+      <View>
+        {results.map((_, index) => (
+          <View style={styles.example} key={index}>
+            <Text style={styles.title}>{_.title}</Text>
+            <ScrollView horizontal style={styles.scroll}>
+              <View style={styles.row}>{_.data}</View>
+            </ScrollView>
+          </View>
         ))}
       </View>
-    </ScrollView>
+    </View>
   );
 }
 
 const styles = StyleSheet.create({
-  root: {
-    flexGrow: 1,
-  },
   container: {
     flex: 1,
-    columnGap: 1,
+    justifyContent: 'center',
+    backgroundColor: '#ffffff',
+  },
+  loader: {
+    padding: 30,
+  },
+  row: {
     flexDirection: 'row',
     alignItems: 'center',
   },
+  title: {
+    marginBottom: 5,
+  },
+  example: {
+    padding: 10,
+  },
+  scroll: {
+    maxHeight: 200,
+  },
   item: {
     width: 3,
-    backgroundColor: 'red',
+    backgroundColor: 'blue',
+    marginHorizontal: 2,
   },
 });

src/helpers.ts

@@ -0,0 +1,88 @@
+export function scale(arr: number[]) {
+  if (arr.length === 0) {
+    return [];
+  }
+
+  const min = Math.min(...arr);
+  const max = Math.max(...arr);
+  const diff = max - min;
+
+  if (diff === 0) {
+    // If diff is 0, all elements in the array are the same.
+    // To avoid division by zero, return an array of the same length with 0 values.
+    return arr.map(() => 0);
+  }
+
+  return arr.map((value) => (value - min) / diff);
+}
+
+export function sample(arr: number[], newSize: number) {
+  const originalSize = arr.length;
+
+  if (newSize === 0) {
+    return [];
+  }
+
+  const result: number[] = [];
+
+  for (let i = 0; i < newSize; i++) {
+    const index = Math.floor((i / newSize) * originalSize);
+    result.push(arr[index] ?? 0);
+  }
+
+  return result;
+}
+
+export function robustScale(arr: number[], q1 = 0.05, q3 = 0.75) {
+  if (arr.length === 0) {
+    return [];
+  }
+
+  const sortedArr = [...arr].sort((a, b) => a - b);
+
+  const q1Index = Math.floor((sortedArr.length - 1) * q1);
+  const q3Index = Math.floor((sortedArr.length - 1) * q3);
+
+  const q1_ = sortedArr[q1Index];
+  const q3_ = sortedArr[q3Index];
+
+  if (q1_ === undefined || q3_ === undefined || q1_ === q3_) {
+    return arr.map(() => 0);
+  }
+
+  const iqr = q3_ - q1_; // Interquartile Range
+
+  return arr.map((value) => {
+    const scaledValue = (value - q1_) / iqr;
+
+    if (scaledValue < 0) return 0;
+    if (scaledValue > 1) return 1;
+    return scaledValue;
+  });
+}
+
+export function trimmedScale(
+  arr: number[],
+  lowerPercentile = 0.03,
+  upperPercentile = 0.95
+) {
+  if (arr.length === 0) {
+    return [];
+  }
+
+  const sortedArr = [...arr].sort((a, b) => a - b);
+
+  const lowerIndex = Math.floor((sortedArr.length - 1) * lowerPercentile);
+  const upperIndex = Math.ceil((sortedArr.length - 1) * upperPercentile);
+
+  const min = sortedArr[lowerIndex];
+  const max = sortedArr[upperIndex];
+
+  if (min === undefined || max === undefined || min === max) {
+    return arr.map(() => 0);
+  }
+
+  const diff = max - min;
+
+  return arr.map((value) => (value - min) / diff);
+}