From fa3ebfb1eb054ba88824a908c996094bb98e85c5 Mon Sep 17 00:00:00 2001 From: a1xd <68629610+a1xd@users.noreply.github.com> Date: Tue, 30 Mar 2021 18:27:02 -0400 Subject: refactor lut/motivity --- common/accel-lookup.hpp | 152 ++++++++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 152 insertions(+) create mode 100644 common/accel-lookup.hpp (limited to 'common/accel-lookup.hpp') diff --git a/common/accel-lookup.hpp b/common/accel-lookup.hpp new file mode 100644 index 0000000..18c9ea5 --- /dev/null +++ b/common/accel-lookup.hpp @@ -0,0 +1,152 @@ +#pragma once + +#include "rawaccel-base.hpp" +#include "utility.hpp" + +namespace rawaccel { + + struct linear_range { + double start; + double stop; + int num; + + template + void for_each(Func fn) const + { + double interval = (stop - start) / (num - 1); + for (int i = 0; i < num; i++) { + fn(i * interval + start); + } + } + + int size() const + { + return num; + } + }; + + + // represents the range [2^start, 2^stop], with num - 1 + // elements linearly spaced between each exponential step + struct fp_rep_range { + int start; + int stop; + int num; + + template + void for_each(Func fn) const + { + for (int e = 0; e < stop - start; e++) { + double exp_scale = scalbn(1, e + start) / num; + + for (int i = 0; i < num; i++) { + fn((i + num) * exp_scale); + } + } + + fn(scalbn(1, stop)); + } + + int size() const + { + return (stop - start) * num + 1; + } + }; + + template + struct lut_base { + enum { capacity = LUT_CAPACITY }; + using value_t = float; + + template + void fill(Func fn) + { + auto* self = static_cast(this); + + self->range.for_each([&, fn, i = 0](double x) mutable { + self->data[i++] = static_cast(fn(x)); + }); + } + + }; + + struct linear_lut : lut_base { + linear_range range; + bool transfer = false; + value_t data[capacity] = {}; + + double operator()(double x) const + { + if (x > range.start) { + double range_dist = range.stop - range.start; + double idx_f = (x - range.start) * (range.num - 1) / range_dist; + + unsigned idx = min(static_cast(idx_f), range.size() - 2); + + if (idx < capacity - 1) { + double y = lerp(data[idx], data[idx + 1], idx_f - idx); + if (transfer) y /= x; + return y; + } + } + + double y = data[0]; + if (transfer) y /= range.start; + return y; + } + + linear_lut(const table_args& args) : + range({ + args.start, + args.stop, + args.num_elements + }), + transfer(args.transfer) {} + + linear_lut(const accel_args& args) : + linear_lut(args.lut_args) {} + }; + + struct binlog_lut : lut_base { + fp_rep_range range; + double x_start; + bool transfer = false; + value_t data[capacity] = {}; + + double operator()(double x) const + { + int e = min(ilogb(x), range.stop - 1); + + if (e >= range.start) { + int idx_int_log_part = e - range.start; + double idx_frac_lin_part = scalbn(x, -e) - 1; + double idx_f = range.num * (idx_int_log_part + idx_frac_lin_part); + + unsigned idx = min(static_cast(idx_f), range.size() - 2); + + if (idx < capacity - 1) { + double y = lerp(data[idx], data[idx + 1], idx_f - idx); + if (transfer) y /= x; + return y; + } + } + + double y = data[0]; + if (transfer) y /= x_start; + return y; + } + + binlog_lut(const table_args& args) : + range({ + static_cast(args.start), + static_cast(args.stop), + args.num_elements + }), + x_start(scalbn(1, range.start)), + transfer(args.transfer) {} + + binlog_lut(const accel_args& args) : + binlog_lut(args.lut_args) {} + }; + +} -- cgit v1.2.3 From 8b3409bdd892481b459a1afbfa6fddea9b7bb448 Mon Sep 17 00:00:00 2001 From: Jacob Palecki Date: Wed, 7 Apr 2021 23:13:01 -0700 Subject: Add arbitrary lut struct --- common/accel-lookup.hpp | 103 ++++++++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 103 insertions(+) (limited to 'common/accel-lookup.hpp') diff --git a/common/accel-lookup.hpp b/common/accel-lookup.hpp index 18c9ea5..6c73605 100644 --- a/common/accel-lookup.hpp +++ b/common/accel-lookup.hpp @@ -149,4 +149,107 @@ namespace rawaccel { binlog_lut(args.lut_args) {} }; + struct si_pair { + double slope = 0; + double intercept = 0; + }; + + struct arbitrary_lut_point { + double applicable_speed = 0; + si_pair slope_intercept = {}; + }; + + struct arbitrary_lut { + fp_rep_range range; + arbitrary_lut_point data[LUT_CAPACITY] = {}; + int log_lookup[LUT_CAPACITY] = {}; + double first_point_speed; + double last_point_speed; + int last_index; + + double operator()(double speed) const + { + int index = 0; + + if (speed < first_point_speed) + { + // Apply from 0 index + } + else if (speed > last_point_speed) + { + index = last_index; + } + else if (speed > range.stop) + { + index = search_from(log_lookup[LUT_CAPACITY - 1], speed); + } + else if (speed < range.start) + { + index = search_from(0, speed); + } + else + { + int log_lookup = get_log_index(speed); + index = search_from(log_lookup, speed); + } + + return apply(index, speed); + } + + int inline get_log_index(double speed) const + { + double speed_log = log(speed) - range.start; + int index = (int)floor(speed_log * range.num); + return index; + } + + int inline search_from(int index, double speed) const + { + int prev_index; + + do + { + prev_index = index; + index++; + } + while (index <= last_index && data[index].applicable_speed < speed); + + index--; + } + + double inline apply(int index, double speed) const + { + si_pair pair = data[index].slope_intercept; + return pair.slope + pair.intercept / speed; + } + + void fill(vec2d* points, int length) const + { + vec2d current = {0, 0}; + vec2d next; + int log_index = 0; + double log_inner_iterator = range.start; + double log_inner_slice = 1 / range.num; + double log_value = pow(2, log_inner_iterator); + + for (int i = 0; i < length; i++) + { + next = points[i]; + double slope = (next.y - current.y) / (next.x - current.x); + double intercept = next.y - slope * next.x; + si_pair current_si = { slope, intercept }; + arbitrary_lut_point current_lut_point = { next.x, current_si }; + + this->data[i] = current_lut_point; + + while (log_value < next.x) + { + this->log_lookup[log_index] = log_value; + log_index++; + log_inner_iterator += log_inner_slice; + log_value = pow(2, log_inner_iterator); + } + } + } + }; } -- cgit v1.2.3 From ea07f6f9eef72e7b126916cd1ae08b18b434dadf Mon Sep 17 00:00:00 2001 From: Jacob Palecki Date: Wed, 7 Apr 2021 23:38:27 -0700 Subject: remove const from uneeded class --- common/accel-lookup.hpp | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) (limited to 'common/accel-lookup.hpp') diff --git a/common/accel-lookup.hpp b/common/accel-lookup.hpp index 6c73605..965cbec 100644 --- a/common/accel-lookup.hpp +++ b/common/accel-lookup.hpp @@ -223,7 +223,7 @@ namespace rawaccel { return pair.slope + pair.intercept / speed; } - void fill(vec2d* points, int length) const + void fill(vec2d* points, int length) { vec2d current = {0, 0}; vec2d next; -- cgit v1.2.3 From b1d1a6ba629acb2e3748398a962ed274fade4e5f Mon Sep 17 00:00:00 2001 From: Jacob Palecki Date: Wed, 7 Apr 2021 23:56:00 -0700 Subject: add constructor and improvements --- common/accel-lookup.hpp | 25 +++++++++++++++++++++---- 1 file changed, 21 insertions(+), 4 deletions(-) (limited to 'common/accel-lookup.hpp') diff --git a/common/accel-lookup.hpp b/common/accel-lookup.hpp index 965cbec..5778de2 100644 --- a/common/accel-lookup.hpp +++ b/common/accel-lookup.hpp @@ -165,7 +165,8 @@ namespace rawaccel { int log_lookup[LUT_CAPACITY] = {}; double first_point_speed; double last_point_speed; - int last_index; + int last_arbitrary_index; + int last_log_lookup_index; double operator()(double speed) const { @@ -177,11 +178,11 @@ namespace rawaccel { } else if (speed > last_point_speed) { - index = last_index; + index = last_arbitrary_index; } else if (speed > range.stop) { - index = search_from(log_lookup[LUT_CAPACITY - 1], speed); + index = search_from(log_lookup[last_log_lookup_index], speed); } else if (speed < range.start) { @@ -212,7 +213,7 @@ namespace rawaccel { prev_index = index; index++; } - while (index <= last_index && data[index].applicable_speed < speed); + while (index <= last_arbitrary_index && data[index].applicable_speed < speed); index--; } @@ -251,5 +252,21 @@ namespace rawaccel { } } } + + arbitrary_lut(vec2d* points, int length) + { + first_point_speed = points[0].x; + // -2 because the last index in the arbitrary array is used for slope-intercept only + last_arbitrary_index = length - 2; + last_point_speed = points[last_arbitrary_index].x; + + double start = (int)floor(log(first_point_speed)); + double end = (int)floor(log(last_point_speed)); + double num = (int)floor(LUT_CAPACITY / (end - start)); + range = fp_rep_range{ start, end, num }; + last_log_lookup_index = num * (end - start) - 1; + + fill(points, length); + } }; } -- cgit v1.2.3 From 3b4a6f179d0c102f578024268f3cde129b384f55 Mon Sep 17 00:00:00 2001 From: Jacob Palecki Date: Thu, 8 Apr 2021 00:02:37 -0700 Subject: Fix return bug --- common/accel-lookup.hpp | 2 ++ 1 file changed, 2 insertions(+) (limited to 'common/accel-lookup.hpp') diff --git a/common/accel-lookup.hpp b/common/accel-lookup.hpp index 5778de2..24b61e5 100644 --- a/common/accel-lookup.hpp +++ b/common/accel-lookup.hpp @@ -216,6 +216,8 @@ namespace rawaccel { while (index <= last_arbitrary_index && data[index].applicable_speed < speed); index--; + + return index; } double inline apply(int index, double speed) const -- cgit v1.2.3 From 6197390760eba8ca1123d03637cbb9af0414c5f7 Mon Sep 17 00:00:00 2001 From: a1xd <68629610+a1xd@users.noreply.github.com> Date: Thu, 8 Apr 2021 12:45:43 -0400 Subject: fix conversions in arbitrary constructor --- common/accel-lookup.hpp | 6 +++--- 1 file changed, 3 insertions(+), 3 deletions(-) (limited to 'common/accel-lookup.hpp') diff --git a/common/accel-lookup.hpp b/common/accel-lookup.hpp index 24b61e5..ff89fa7 100644 --- a/common/accel-lookup.hpp +++ b/common/accel-lookup.hpp @@ -262,9 +262,9 @@ namespace rawaccel { last_arbitrary_index = length - 2; last_point_speed = points[last_arbitrary_index].x; - double start = (int)floor(log(first_point_speed)); - double end = (int)floor(log(last_point_speed)); - double num = (int)floor(LUT_CAPACITY / (end - start)); + int start = static_cast(log(first_point_speed)); + int end = static_cast(log(last_point_speed)); + int num = static_cast(LUT_CAPACITY / (end - start)); range = fp_rep_range{ start, end, num }; last_log_lookup_index = num * (end - start) - 1; -- cgit v1.2.3 From 74ffcb8553795f4b50e544a1b2a0e53aec32a860 Mon Sep 17 00:00:00 2001 From: a1xd <68629610+a1xd@users.noreply.github.com> Date: Thu, 8 Apr 2021 21:48:17 -0400 Subject: make sizeof arbitrary close to others refactor constructor/fix conversions --- common/accel-lookup.hpp | 57 ++++++++++++++++++++++++++++++------------------- 1 file changed, 35 insertions(+), 22 deletions(-) (limited to 'common/accel-lookup.hpp') diff --git a/common/accel-lookup.hpp b/common/accel-lookup.hpp index ff89fa7..6ebc90b 100644 --- a/common/accel-lookup.hpp +++ b/common/accel-lookup.hpp @@ -3,6 +3,8 @@ #include "rawaccel-base.hpp" #include "utility.hpp" +#include + namespace rawaccel { struct linear_range { @@ -55,7 +57,7 @@ namespace rawaccel { template struct lut_base { - enum { capacity = LUT_CAPACITY }; + enum { capacity = SPACED_LUT_CAPACITY }; using value_t = float; template @@ -150,19 +152,21 @@ namespace rawaccel { }; struct si_pair { - double slope = 0; - double intercept = 0; + float slope = 0; + float intercept = 0; }; struct arbitrary_lut_point { - double applicable_speed = 0; + float applicable_speed = 0; si_pair slope_intercept = {}; }; struct arbitrary_lut { + enum { capacity = SPACED_LUT_CAPACITY / 4 }; + fp_rep_range range; - arbitrary_lut_point data[LUT_CAPACITY] = {}; - int log_lookup[LUT_CAPACITY] = {}; + arbitrary_lut_point data[capacity] = {}; + int log_lookup[capacity] = {}; double first_point_speed; double last_point_speed; int last_arbitrary_index; @@ -226,8 +230,20 @@ namespace rawaccel { return pair.slope + pair.intercept / speed; } - void fill(vec2d* points, int length) + + void init(vec2d* points, int length) { + first_point_speed = points[0].x; + // -2 because the last index in the arbitrary array is used for slope-intercept only + last_arbitrary_index = length - 2; + last_point_speed = points[last_arbitrary_index].x; + + int start = static_cast(floor(log(first_point_speed))); + int end = static_cast(floor(log(last_point_speed))); + int num = static_cast(capacity / (end - start)); + range = fp_rep_range{ start, end, num }; + last_log_lookup_index = num * (end - start) - 1; + vec2d current = {0, 0}; vec2d next; int log_index = 0; @@ -240,14 +256,20 @@ namespace rawaccel { next = points[i]; double slope = (next.y - current.y) / (next.x - current.x); double intercept = next.y - slope * next.x; - si_pair current_si = { slope, intercept }; - arbitrary_lut_point current_lut_point = { next.x, current_si }; + si_pair current_si = { + static_cast(slope), + static_cast(intercept) + }; + arbitrary_lut_point current_lut_point = { + static_cast(next.x), + current_si + }; this->data[i] = current_lut_point; while (log_value < next.x) { - this->log_lookup[log_index] = log_value; + this->log_lookup[log_index] = static_cast(log_value); log_index++; log_inner_iterator += log_inner_slice; log_value = pow(2, log_inner_iterator); @@ -257,18 +279,9 @@ namespace rawaccel { arbitrary_lut(vec2d* points, int length) { - first_point_speed = points[0].x; - // -2 because the last index in the arbitrary array is used for slope-intercept only - last_arbitrary_index = length - 2; - last_point_speed = points[last_arbitrary_index].x; - - int start = static_cast(log(first_point_speed)); - int end = static_cast(log(last_point_speed)); - int num = static_cast(LUT_CAPACITY / (end - start)); - range = fp_rep_range{ start, end, num }; - last_log_lookup_index = num * (end - start) - 1; - - fill(points, length); + init(points, length); } + + arbitrary_lut(const accel_args&) {} }; } -- cgit v1.2.3 From 1494d248953ceedadd7a8e2fef7c957fa1f7350e Mon Sep 17 00:00:00 2001 From: a1xd <68629610+a1xd@users.noreply.github.com> Date: Thu, 8 Apr 2021 22:00:08 -0400 Subject: make it safe --- common/accel-lookup.hpp | 49 ++++++++++++++++++++++++++++--------------------- 1 file changed, 28 insertions(+), 21 deletions(-) (limited to 'common/accel-lookup.hpp') diff --git a/common/accel-lookup.hpp b/common/accel-lookup.hpp index 6ebc90b..6eb16d9 100644 --- a/common/accel-lookup.hpp +++ b/common/accel-lookup.hpp @@ -175,27 +175,34 @@ namespace rawaccel { double operator()(double speed) const { int index = 0; + int last_arb_index = last_arbitrary_index; + int last_log_index = last_log_lookup_index; - if (speed < first_point_speed) + if (unsigned(last_arb_index) < capacity && + unsigned(last_log_index) < capacity && + speed > first_point_speed) { - // Apply from 0 index - } - else if (speed > last_point_speed) - { - index = last_arbitrary_index; - } - else if (speed > range.stop) - { - index = search_from(log_lookup[last_log_lookup_index], speed); - } - else if (speed < range.start) - { - index = search_from(0, speed); - } - else - { - int log_lookup = get_log_index(speed); - index = search_from(log_lookup, speed); + if (speed > last_point_speed) + { + index = last_arb_index; + } + else if (speed > range.stop) + { + int last_log = log_lookup[last_log_index]; + if (unsigned(last_log) >= capacity) return 1; + index = search_from(last_log, last_arb_index, speed); + } + else if (speed < range.start) + { + index = search_from(0, last_arb_index, speed); + } + else + { + int log_index = get_log_index(speed); + if (unsigned(log_index) >= capacity) return 1; + index = search_from(log_index, last_arb_index, speed); + } + } return apply(index, speed); @@ -208,7 +215,7 @@ namespace rawaccel { return index; } - int inline search_from(int index, double speed) const + int inline search_from(int index, int last, double speed) const { int prev_index; @@ -217,7 +224,7 @@ namespace rawaccel { prev_index = index; index++; } - while (index <= last_arbitrary_index && data[index].applicable_speed < speed); + while (index <= last && data[index].applicable_speed < speed); index--; -- cgit v1.2.3 From aad1822effaa16c29dba316601923f31d66ce063 Mon Sep 17 00:00:00 2001 From: Jacob Palecki Date: Thu, 8 Apr 2021 21:49:25 -0700 Subject: Progress in arbitrary --- common/accel-lookup.hpp | 15 ++++++++------- 1 file changed, 8 insertions(+), 7 deletions(-) (limited to 'common/accel-lookup.hpp') diff --git a/common/accel-lookup.hpp b/common/accel-lookup.hpp index 24b61e5..be107f8 100644 --- a/common/accel-lookup.hpp +++ b/common/accel-lookup.hpp @@ -163,6 +163,7 @@ namespace rawaccel { fp_rep_range range; arbitrary_lut_point data[LUT_CAPACITY] = {}; int log_lookup[LUT_CAPACITY] = {}; + float raw_data_in[LUT_CAPACITY * 2] = {}; double first_point_speed; double last_point_speed; int last_arbitrary_index; @@ -226,7 +227,7 @@ namespace rawaccel { return pair.slope + pair.intercept / speed; } - void fill(vec2d* points, int length) + void fill(float* points, int length) { vec2d current = {0, 0}; vec2d next; @@ -237,7 +238,7 @@ namespace rawaccel { for (int i = 0; i < length; i++) { - next = points[i]; + next = vec2d{ points[i * 2], points[i * 2 + 1] }; double slope = (next.y - current.y) / (next.x - current.x); double intercept = next.y - slope * next.x; si_pair current_si = { slope, intercept }; @@ -255,12 +256,12 @@ namespace rawaccel { } } - arbitrary_lut(vec2d* points, int length) + arbitrary_lut(const table_args &args) { - first_point_speed = points[0].x; + first_point_speed = raw_data_in[0]; // -2 because the last index in the arbitrary array is used for slope-intercept only - last_arbitrary_index = length - 2; - last_point_speed = points[last_arbitrary_index].x; + last_arbitrary_index = (length - 2)*2; + last_point_speed = raw_data_in[last_arbitrary_index]; double start = (int)floor(log(first_point_speed)); double end = (int)floor(log(last_point_speed)); @@ -268,7 +269,7 @@ namespace rawaccel { range = fp_rep_range{ start, end, num }; last_log_lookup_index = num * (end - start) - 1; - fill(points, length); + fill(raw_data_in, length); } }; } -- cgit v1.2.3 From e5e7896d0df3f73bf153a83dd5022ccf6365f8ee Mon Sep 17 00:00:00 2001 From: Jacob Palecki Date: Fri, 9 Apr 2021 00:42:55 -0700 Subject: Fixed some bugs --- common/accel-lookup.hpp | 18 +++++++++++------- 1 file changed, 11 insertions(+), 7 deletions(-) (limited to 'common/accel-lookup.hpp') diff --git a/common/accel-lookup.hpp b/common/accel-lookup.hpp index f70f2b1..c014b84 100644 --- a/common/accel-lookup.hpp +++ b/common/accel-lookup.hpp @@ -172,6 +172,8 @@ namespace rawaccel { double last_point_speed; int last_arbitrary_index; int last_log_lookup_index; + double last_log_lookup_speed; + double first_log_lookup_speed; double operator()(double speed) const { @@ -187,13 +189,13 @@ namespace rawaccel { { index = last_arb_index; } - else if (speed > range.stop) + else if (speed > last_log_lookup_speed) { int last_log = log_lookup[last_log_index]; if (unsigned(last_log) >= capacity) return 1; index = search_from(last_log, last_arb_index, speed); } - else if (speed < range.start) + else if (speed < first_log_lookup_speed) { index = search_from(0, last_arb_index, speed); } @@ -246,8 +248,10 @@ namespace rawaccel { last_arbitrary_index = length - 2; last_point_speed = points[last_arbitrary_index].x; - int start = static_cast(floor(log(first_point_speed))); - int end = static_cast(floor(log(last_point_speed))); + int start = static_cast(floor(log(first_point_speed) / log(2.0))); + first_log_lookup_speed = pow(2.0, start); + int end = static_cast(floor(log(last_point_speed) / log(2.0))); + last_log_lookup_speed = pow(2.0, end); int num = static_cast(capacity / (end - start)); range = fp_rep_range{ start, end, num }; last_log_lookup_index = num * (end - start) - 1; @@ -256,7 +260,7 @@ namespace rawaccel { vec2 next; int log_index = 0; double log_inner_iterator = range.start; - double log_inner_slice = 1 / range.num; + double log_inner_slice = 1.0 / (range.num * 1.0); double log_value = pow(2, log_inner_iterator); for (int i = 0; i < length; i++) @@ -275,9 +279,9 @@ namespace rawaccel { this->data[i] = current_lut_point; - while (log_value < next.x) + while (log_value < next.x && log_inner_iterator < end) { - this->log_lookup[log_index] = static_cast(log_value); + this->log_lookup[log_index] = i; log_index++; log_inner_iterator += log_inner_slice; log_value = pow(2, log_inner_iterator); -- cgit v1.2.3 From 060b79bda0b656bd9aec253389706681a565443e Mon Sep 17 00:00:00 2001 From: Jacob Palecki Date: Fri, 9 Apr 2021 16:27:32 -0700 Subject: Some more small additions and fixes --- common/accel-lookup.hpp | 15 ++++++++++----- 1 file changed, 10 insertions(+), 5 deletions(-) (limited to 'common/accel-lookup.hpp') diff --git a/common/accel-lookup.hpp b/common/accel-lookup.hpp index c014b84..97af0ff 100644 --- a/common/accel-lookup.hpp +++ b/common/accel-lookup.hpp @@ -167,6 +167,7 @@ namespace rawaccel { fp_rep_range range; ; arbitrary_lut_point data[capacity] = {}; + float raw_data_in[capacity*2] = {}; int log_lookup[capacity] = {}; double first_point_speed; double last_point_speed; @@ -248,10 +249,10 @@ namespace rawaccel { last_arbitrary_index = length - 2; last_point_speed = points[last_arbitrary_index].x; - int start = static_cast(floor(log(first_point_speed) / log(2.0))); - first_log_lookup_speed = pow(2.0, start); - int end = static_cast(floor(log(last_point_speed) / log(2.0))); - last_log_lookup_speed = pow(2.0, end); + int start = static_cast(floor(log(first_point_speed))); + first_log_lookup_speed = exp(start*1.0); + int end = static_cast(floor(log(last_point_speed))); + last_log_lookup_speed = exp(end*1.0); int num = static_cast(capacity / (end - start)); range = fp_rep_range{ start, end, num }; last_log_lookup_index = num * (end - start) - 1; @@ -266,6 +267,8 @@ namespace rawaccel { for (int i = 0; i < length; i++) { next = points[i]; + raw_data_in[i * 2] = next.x; + raw_data_in[i * 2 + 1] = next.y; double slope = (next.y - current.y) / (next.x - current.x); double intercept = next.y - slope * next.x; si_pair current_si = { @@ -284,8 +287,10 @@ namespace rawaccel { this->log_lookup[log_index] = i; log_index++; log_inner_iterator += log_inner_slice; - log_value = pow(2, log_inner_iterator); + log_value = exp(log_inner_iterator); } + + current = next; } } -- cgit v1.2.3 From 93f4475f969e75e9722edaad3645c51b184786d6 Mon Sep 17 00:00:00 2001 From: Jacob Palecki Date: Fri, 9 Apr 2021 17:03:31 -0700 Subject: Mostly working now --- common/accel-lookup.hpp | 11 ++++++----- 1 file changed, 6 insertions(+), 5 deletions(-) (limited to 'common/accel-lookup.hpp') diff --git a/common/accel-lookup.hpp b/common/accel-lookup.hpp index 97af0ff..4314bfa 100644 --- a/common/accel-lookup.hpp +++ b/common/accel-lookup.hpp @@ -204,7 +204,8 @@ namespace rawaccel { { int log_index = get_log_index(speed); if (unsigned(log_index) >= capacity) return 1; - index = search_from(log_index, last_arb_index, speed); + int arbitrary_index = log_lookup[log_index]; + index = search_from(arbitrary_index, last_arb_index, speed); } } @@ -245,9 +246,9 @@ namespace rawaccel { void fill(vec2* points, int length) { first_point_speed = points[0].x; + last_arbitrary_index = length - 1; // -2 because the last index in the arbitrary array is used for slope-intercept only - last_arbitrary_index = length - 2; - last_point_speed = points[last_arbitrary_index].x; + last_point_speed = points[length-2].x; int start = static_cast(floor(log(first_point_speed))); first_log_lookup_speed = exp(start*1.0); @@ -262,7 +263,7 @@ namespace rawaccel { int log_index = 0; double log_inner_iterator = range.start; double log_inner_slice = 1.0 / (range.num * 1.0); - double log_value = pow(2, log_inner_iterator); + double log_value = exp(log_inner_iterator); for (int i = 0; i < length; i++) { @@ -276,7 +277,7 @@ namespace rawaccel { static_cast(intercept) }; arbitrary_lut_point current_lut_point = { - static_cast(next.x), + static_cast(current.x), current_si }; -- cgit v1.2.3 From f1aae3548db5096fbea879d5c92cec532e606e5b Mon Sep 17 00:00:00 2001 From: Jacob Palecki Date: Fri, 9 Apr 2021 17:38:32 -0700 Subject: additional fixes --- common/accel-lookup.hpp | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) (limited to 'common/accel-lookup.hpp') diff --git a/common/accel-lookup.hpp b/common/accel-lookup.hpp index 4314bfa..968eb6a 100644 --- a/common/accel-lookup.hpp +++ b/common/accel-lookup.hpp @@ -254,9 +254,9 @@ namespace rawaccel { first_log_lookup_speed = exp(start*1.0); int end = static_cast(floor(log(last_point_speed))); last_log_lookup_speed = exp(end*1.0); - int num = static_cast(capacity / (end - start)); + int num = end > start ? static_cast(capacity / (end - start)) : 1; range = fp_rep_range{ start, end, num }; - last_log_lookup_index = num * (end - start) - 1; + last_log_lookup_index = end > start ? num * (end - start) - 1 : 0; vec2 current = {0, 0}; vec2 next; -- cgit v1.2.3 From a6926be0e911b7b7637861866f41c3bca31a87a3 Mon Sep 17 00:00:00 2001 From: a1xd <68629610+a1xd@users.noreply.github.com> Date: Tue, 13 Apr 2021 23:59:21 -0400 Subject: move arbitrary input into settings separate arbitrary mode from spaced modes, arbitrary now deserializes from default settings file --- common/accel-lookup.hpp | 35 +++++++++++++++++++++-------------- 1 file changed, 21 insertions(+), 14 deletions(-) (limited to 'common/accel-lookup.hpp') diff --git a/common/accel-lookup.hpp b/common/accel-lookup.hpp index 968eb6a..4e8354f 100644 --- a/common/accel-lookup.hpp +++ b/common/accel-lookup.hpp @@ -97,7 +97,7 @@ namespace rawaccel { return y; } - linear_lut(const table_args& args) : + linear_lut(const spaced_lut_args& args) : range({ args.start, args.stop, @@ -106,7 +106,7 @@ namespace rawaccel { transfer(args.transfer) {} linear_lut(const accel_args& args) : - linear_lut(args.lut_args) {} + linear_lut(args.spaced_args) {} }; struct binlog_lut : lut_base { @@ -138,7 +138,7 @@ namespace rawaccel { return y; } - binlog_lut(const table_args& args) : + binlog_lut(const spaced_lut_args& args) : range({ static_cast(args.start), static_cast(args.stop), @@ -148,7 +148,7 @@ namespace rawaccel { transfer(args.transfer) {} binlog_lut(const accel_args& args) : - binlog_lut(args.lut_args) {} + binlog_lut(args.spaced_args) {} }; struct si_pair { @@ -162,12 +162,10 @@ namespace rawaccel { }; struct arbitrary_lut { - enum { capacity = SPACED_LUT_CAPACITY / 4 }; + enum { capacity = ARB_LUT_CAPACITY }; fp_rep_range range; -; arbitrary_lut_point data[capacity] = {}; - float raw_data_in[capacity*2] = {}; int log_lookup[capacity] = {}; double first_point_speed; double last_point_speed; @@ -175,6 +173,7 @@ namespace rawaccel { int last_log_lookup_index; double last_log_lookup_speed; double first_log_lookup_speed; + bool velocity_points; double operator()(double speed) const { @@ -205,6 +204,7 @@ namespace rawaccel { int log_index = get_log_index(speed); if (unsigned(log_index) >= capacity) return 1; int arbitrary_index = log_lookup[log_index]; + if (arbitrary_index < 0) return 1; index = search_from(arbitrary_index, last_arb_index, speed); } @@ -238,12 +238,19 @@ namespace rawaccel { double inline apply(int index, double speed) const { - si_pair pair = data[index].slope_intercept; - return pair.slope + pair.intercept / speed; - } + auto [slope, intercept] = data[index].slope_intercept; + if (velocity_points) + { + return slope + intercept / speed; + } + else + { + return slope * speed + intercept; + } + } - void fill(vec2* points, int length) + void fill(const vec2* points, int length) { first_point_speed = points[0].x; last_arbitrary_index = length - 1; @@ -268,8 +275,6 @@ namespace rawaccel { for (int i = 0; i < length; i++) { next = points[i]; - raw_data_in[i * 2] = next.x; - raw_data_in[i * 2 + 1] = next.y; double slope = (next.y - current.y) / (next.x - current.x); double intercept = next.y - slope * next.x; si_pair current_si = { @@ -295,8 +300,10 @@ namespace rawaccel { } } - arbitrary_lut(const accel_args&) + arbitrary_lut(const accel_args& args) { + velocity_points = args.arb_args.velocity; + fill(args.arb_args.data, args.arb_args.length); } }; } -- cgit v1.2.3 From 7a08f3e261b7799cbc1daad54c1fbc2d5ec363a4 Mon Sep 17 00:00:00 2001 From: a1xd <68629610+a1xd@users.noreply.github.com> Date: Wed, 14 Apr 2021 00:13:19 -0400 Subject: fix arbitrary output starting from 0 in sens mode --- common/accel-lookup.hpp | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) (limited to 'common/accel-lookup.hpp') diff --git a/common/accel-lookup.hpp b/common/accel-lookup.hpp index 4e8354f..2ca387f 100644 --- a/common/accel-lookup.hpp +++ b/common/accel-lookup.hpp @@ -265,7 +265,7 @@ namespace rawaccel { range = fp_rep_range{ start, end, num }; last_log_lookup_index = end > start ? num * (end - start) - 1 : 0; - vec2 current = {0, 0}; + vec2 current = {0, velocity_points ? 0.0f : 1.0f }; vec2 next; int log_index = 0; double log_inner_iterator = range.start; -- cgit v1.2.3 From 0bff91add8525c3c3b3ac00d0508d3a798dee5e2 Mon Sep 17 00:00:00 2001 From: a1xd <68629610+a1xd@users.noreply.github.com> Date: Wed, 14 Apr 2021 21:30:26 -0400 Subject: ensure normal return values from accel --- common/accel-lookup.hpp | 11 ++++------- 1 file changed, 4 insertions(+), 7 deletions(-) (limited to 'common/accel-lookup.hpp') diff --git a/common/accel-lookup.hpp b/common/accel-lookup.hpp index 2ca387f..99f39e9 100644 --- a/common/accel-lookup.hpp +++ b/common/accel-lookup.hpp @@ -181,6 +181,8 @@ namespace rawaccel { int last_arb_index = last_arbitrary_index; int last_log_index = last_log_lookup_index; + if (speed <= 0) return 1; + if (unsigned(last_arb_index) < capacity && unsigned(last_log_index) < capacity && speed > first_point_speed) @@ -222,18 +224,13 @@ namespace rawaccel { int inline search_from(int index, int last, double speed) const { - int prev_index; - do { - prev_index = index; index++; - } + } while (index <= last && data[index].applicable_speed < speed); - index--; - - return index; + return index - 1; } double inline apply(int index, double speed) const -- cgit v1.2.3