Always pass `step` to `slice_from_time()` in the `Viz`

As per the change to `slice_from_time()` this ensures this `Viz` always
passes its self-calculated time indexing step size to the time slicing
routine(s).

Further this contains a slight impl tweak to `.scalars_from_index()` to
slice the actual view range from `xref` to `Viz.ViewState.xrange[1]` and
then reading the corresponding `yref` from the first entry in that
array; this should be no slower in theory and makes way for further
caching of x-read-range to `ViewState` opportunities later.
log_linearized_curve_overlays
Tyler Goodlet 2023-03-07 15:05:42 -05:00
parent 712f1a47a0
commit 32926747c6
1 changed files with 33 additions and 9 deletions

View File

@ -239,6 +239,8 @@ class ViewState(Struct):
float | int
] | None = None
# TODO: cache the (ixl, ixr) read_slc-into-.array style slice index?
# (ymn, ymx) "output" min and max in viewed y-codomain
yrange: tuple[
float | int,
@ -655,6 +657,7 @@ class Viz(Struct):
array,
start_t=lbar,
stop_t=rbar,
step=self.index_step(),
)
# TODO: maybe we should return this from the slicer call
@ -1400,8 +1403,23 @@ class Viz(Struct):
self,
xref: float | None = None,
) -> tuple[int, float, float, float]:
) -> tuple[
int,
float,
float,
float,
]:
'''
Calculate and deliver the log-returns scalars specifically
according to y-data supported on this ``Viz``'s underlying
x-domain data range from ``xref`` -> ``.vs.xrange[1]``.
The main use case for this method (currently) is to generate
scalars which will allow calculating the required y-range for
some "pinned" curve to be aligned *from* the ``xref`` time
stamped datum *to* the curve rendered by THIS viz.
'''
vs = self.vs
arr = vs.in_view
@ -1409,22 +1427,28 @@ class Viz(Struct):
# .vs.xrange input for caching?
# read_slc_start = self.i_from_t(xref)
slc = slice_from_time(
read_slc = slice_from_time(
arr=self.vs.in_view,
start_t=xref,
stop_t=xref,
stop_t=vs.xrange[1],
step=self.index_step(),
)
read_slc_start = slc.start
key = 'open' if self.is_ohlc else self.name
yref = arr[read_slc_start][key]
# NOTE: old code, it's no faster right?
# read_slc_start = read_slc.start
# yref = arr[read_slc_start][key]
read = arr[read_slc][key]
yref = read[0]
ymn, ymx = self.vs.yrange
# print(
# f'INTERSECT xref: {read_slc_start}\n'
# f'ymn, ymx: {(ymn, ymx)}\n'
# f'Viz[{self.name}].scalars_from_index(xref={xref})\n'
# f'read_slc: {read_slc}\n'
# f'ymnmx: {(ymn, ymx)}\n'
# )
return (
read_slc_start,
read_slc.start,
yref,
(ymx - yref) / yref,
(ymn - yref) / yref,