X-Git-Url: https://sigrok.org/gitweb/?a=blobdiff_plain;f=src%2Fanalog.c;h=634e9a674ba8ada7817bd489d68bedbe7853ed59;hb=962172e4950f3fbc42d5a79cdf63dc179d7513be;hp=a04844d67a7df13040d73aab775b3e053b325f57;hpb=bdba362695bd5ee97fca685839a9e90e1e788ecb;p=libsigrok.git

diff --git a/src/analog.c b/src/analog.c
index a04844d6..634e9a67 100644
--- a/src/analog.c
+++ b/src/analog.c
@@ -22,6 +22,7 @@
 #include <stdint.h>
 #include <string.h>
 #include <ctype.h>
+#include <math.h>
 #include <libsigrok/libsigrok.h>
 #include "libsigrok-internal.h"
 
@@ -292,6 +293,37 @@ SR_API int sr_analog_to_float(const struct sr_datafeed_analog *analog,
 	return SR_OK;
 }
 
+/**
+ * Scale a float value to the appropriate SI prefix.
+ *
+ * @param[in,out] value The float value to convert to appropriate SI prefix.
+ * @param[in,out] digits The number of significant decimal digits in value.
+ *
+ * @return The SI prefix to which value was scaled, as a printable string.
+ *
+ * @since 0.5.0
+ */
+SR_API const char *sr_analog_si_prefix(float *value, int *digits)
+{
+#define NEG_PREFIX_COUNT 5  /* number of prefixes below unity */
+#define POS_PREFIX_COUNT (int)(ARRAY_SIZE(prefixes) - NEG_PREFIX_COUNT - 1)
+	static const char *prefixes[] = { "f","p","n","µ","m","","k","M","G","T" };
+
+	if (value == NULL || digits == NULL || isnan(*value))
+		return prefixes[NEG_PREFIX_COUNT];
+
+	float logval = log10f(fabsf(*value));
+	int prefix = (logval / 3) - (logval < 1);
+
+	if (prefix < -NEG_PREFIX_COUNT) prefix = -NEG_PREFIX_COUNT;
+	if (3 * prefix < -*digits)      prefix = (-*digits + 2 * (*digits < 0)) / 3;
+	if (prefix > POS_PREFIX_COUNT)  prefix = POS_PREFIX_COUNT;
+
+	*value *= powf(10, -3 * prefix);
+	*digits += 3 * prefix;
+	return prefixes[prefix + NEG_PREFIX_COUNT];
+}
+
 /**
  * Convert the unit/MQ/MQ flags in the analog struct to a string.
  *
@@ -433,4 +465,120 @@ SR_API int sr_rational_eq(const struct sr_rational *a, const struct sr_rational
 #endif
 }
 
+/**
+ * Multiply two sr_rational
+ *
+ * @param[in] a First value
+ * @param[in] b Second value
+ * @param[out] res Result
+ *
+ * The resulting nominator/denominator are reduced if the result would not fit
+ * otherwise. If the resulting nominator/denominator are relatively prime,
+ * this may not be possible.
+ *
+ * It is save to use the same variable for result and input values
+ *
+ * @retval SR_OK Success.
+ * @retval SR_ERR_ARG Resulting value to large
+ *
+ * @since 0.5.0
+ */
+SR_API int sr_rational_mult(struct sr_rational *res, const struct sr_rational *a,
+	const struct sr_rational *b)
+{
+#ifdef HAVE___INT128_T
+	__int128_t p;
+	__uint128_t q;
+
+	p = (__int128_t)(a->p) * (__int128_t)(b->p);
+	q = (__uint128_t)(a->q) * (__uint128_t)(b->q);
+
+	if ((p > INT64_MAX) || (p < INT64_MIN) || (q > UINT64_MAX)) {
+		while (!((p & 1) || (q & 1))) {
+			p /= 2;
+			q /= 2;
+		}
+	}
+
+	if ((p > INT64_MAX) || (p < INT64_MIN) || (q > UINT64_MAX)) {
+		// TODO: determine gcd to do further reduction
+		return SR_ERR_ARG;
+	}
+
+	res->p = (int64_t)(p);
+	res->q = (uint64_t)(q);
+
+	return SR_OK;
+
+#else
+	struct sr_int128_t p;
+	struct sr_uint128_t q;
+
+	mult_int64(&p, a->p, b->p);
+	mult_uint64(&q, a->q, b->q);
+
+	while (!(p.low & 1) && !(q.low & 1)) {
+		p.low /= 2;
+		if (p.high & 1) p.low |= (1ll << 63);
+		p.high >>= 1;
+		q.low /= 2;
+		if (q.high & 1) q.low |= (1ll << 63);
+		q.high >>= 1;
+	}
+
+	if (q.high)
+		return SR_ERR_ARG;
+	if ((p.high >= 0) && (p.low > INT64_MAX))
+		return SR_ERR_ARG;
+	if (p.high < -1)
+		return SR_ERR_ARG;
+
+	res->p = (int64_t)p.low;
+	res->q = q.low;
+
+	return SR_OK;
+#endif
+}
+
+/**
+ * Divide rational a by rational b
+ *
+ * @param[in] num numerator
+ * @param[in] div divisor
+ * @param[out] res Result
+ *
+ * The resulting nominator/denominator are reduced if the result would not fit
+ * otherwise. If the resulting nominator/denominator are relatively prime,
+ * this may not be possible.
+ *
+ * It is save to use the same variable for result and input values
+ *
+ * @retval SR_OK Success.
+ * @retval SR_ERR_ARG Division by zero
+ * @retval SR_ERR_ARG Denominator of divisor to large
+ * @retval SR_ERR_ARG Resulting value to large
+ *
+ * @since 0.5.0
+ */
+SR_API int sr_rational_div(struct sr_rational *res, const struct sr_rational *num,
+	const struct sr_rational *div)
+{
+	struct sr_rational t;
+
+	if (div->q > INT64_MAX)
+		return SR_ERR_ARG;
+	if (div->p == 0)
+		return SR_ERR_ARG;
+
+	if (div->p > 0) {
+		t.p = div->q;
+		t.q = div->p;
+	} else {
+		t.p = -div->q;
+		t.q = -div->p;
+	}
+
+	return sr_rational_mult(res, num, &t);
+}
+
 /** @} */