Support Board

SCFloatArrayRef o_s_Shaved_UP = E_Subgraph_ExtraArrays.Arrays[2];
SCFloatArrayRef o_s_Shaved_DOWN = E_Subgraph_ExtraArrays.Arrays[3];

//{{{ o_s_Shaved_UP
SCSubgraphRef o_s_Shaved_UP = sc.Subgraph[o_s++];
if (sc.SetDefaults)
{
o_s_Shaved_UP.Name = "o_s_Shaved_UP";
o_s_Shaved_UP.DrawStyle = DRAWSTYLE_COLOR_BAR_CANDLE_FILL;
o_s_Shaved_UP.PrimaryColor = COLOR_AQUA;
o_s_Shaved_UP.LineWidth = 5;
o_s_Shaved_UP.DrawZeros = false;
}
//}}}

//{{{ o_s_Shaved_DOWN
SCSubgraphRef o_s_Shaved_DOWN = sc.Subgraph[o_s++];
if (sc.SetDefaults)
{
o_s_Shaved_DOWN.Name = "o_s_Shaved_DOWN";
o_s_Shaved_DOWN.DrawStyle = DRAWSTYLE_COLOR_BAR_CANDLE_FILL;
o_s_Shaved_DOWN.PrimaryColor = COLOR_PINK;
o_s_Shaved_DOWN.LineWidth = 5;
o_s_Shaved_DOWN.DrawZeros = false;
}
//}}}

struct Deque_mgr {
//{{{ sliding window storage add scIndex
/* think of this as a sliding window on the price data, we only typically look at the last x values
* and we dont' want to store all 100k bars...so just the last 3k bars is reasonable.*/
std::deque<float> window;
int max_size;
int last_index = -1; // Initialize with an impossible index
float dummy = 0.0f; // default value when no entries exist

Deque_mgr(int size = 10, int li = -1) : max_size(size), last_index(li), dummy(0.0f) {}

bool add(float value, int scIndex) {
//{{{
if (last_index == scIndex) {
return false; // No update needed, index already processed
}

// Update the last processed index
last_index = scIndex;

// Manage the deque size
if (window.size() >= max_size) {
window.pop_front();
}

window.push_back(value);
return true;
//}}}
}

float& operator[](int index) {
//{{{ Access elements with a negative index, e.g., -1 for the last element
if (window.empty() ) {
return dummy; /* Return a reference to a dummy value if out of range or empty */
}

if (index < 0) {
index = (int)window.size() + index; // Convert negative index to positive
}

// Clamp index to valid range to avoid out of range errors
index = std::clamp(index, 0, static_cast<int>(window.size()) - 1);
return window[index];
//}}}
}

const float& operator[](int index) const {
//{{{ For const objects, provide a const version of the operator[]
static float dummy = 0.0f; // Static to ensure the reference remains valid
if (window.empty() ) {
return dummy; // Return a reference to a dummy value if out of range or empty
}

if (index < 0) {
index = (int)window.size() + index; // Convert negative index to positive
}
// Clamp index to valid range to avoid out of range errors
index = std::clamp(index, 0, static_cast<int>(window.size()) - 1);
return window[index];
//}}}
}

//}}}
};

struct p_deque_mgr {
//{{{
std::unordered_map<std::string, Deque_mgr> mw;

p_deque_mgr() {
mw.reserve(100); // Reserve space for 100 memory windows(elements) to minimize rehashing
}

// Add a new manager with a custom name and size
void add_memWindow(const std::string& name, int size) {
mw[name] = Deque_mgr(size);
}

// Access a manager by name
Deque_mgr& operator[](const std::string& name) {
return mw[name];
}


void reset() {
//{{{ Reset all Deque_mgr instances, clearing their content
for (auto& pair : mw) {
pair.second.window.clear(); // Clear each deque
}
//}}}
}


void example_use() {
//{{{ Example of use
add_memWindow("customName1", 10);
add_memWindow("customName2", 15);

mw["customName1"].add(10.0f, 1);
std::cout << "customName1[-1]: " << mw["customName1"][-1] << std::endl;

mw["customName2"].add(20.0f, 1);
mw["customName2"].add(30.0f, 1);
std::cout << "customName2[-2]: " << mw["customName2"][-2] << std::endl;
//}}}
}


//}}}
};

const std::int32_t p_deque_mgr_pkey = 222282;

p_deque_mgr* dmm = reinterpret_cast<p_deque_mgr*>(sc.GetPersistentPointer(p_deque_mgr_pkey));

if (dmm == nullptr)
sc.SetPersistentPointer(p_deque_mgr_pkey, new p_deque_mgr()); // Set the new instance as a persistent pointer

//DON'T forget to delete on last calculation
if (sc.LastCallToFunction){


if (dmm == nullptr)
//do nothing
int a = 1;
else
delete dmm;
}

if(sc.Index == 0){
//{{{ setup other equivalent output subgraphs --- but can't be used in a 'calculate' function that expects a subgraph
dmm->reset();
dmm->add_memWindow("o_Subgraph_RDA_ATR", MAX_WINDOW_SIZE);
dmm->add_memWindow("o_s_waveTop", MAX_WINDOW_SIZE);
dmm->add_memWindow("o_s_waveBottom", MAX_WINDOW_SIZE);
dmm->add_memWindow("o_s_lastWaveTopPrice", MAX_WINDOW_SIZE);
dmm->add_memWindow("o_s_lastWaveBottomPrice", MAX_WINDOW_SIZE);
dmm->add_memWindow("o_s_waveTopHH", MAX_WINDOW_SIZE);
dmm->add_memWindow("o_s_waveBottomLL", MAX_WINDOW_SIZE);
//}}}
}

dmm->mw["o_s_waveTop"].add(waveTop_ID310,sc.Index);

float curValue= dmm->mw["o_s_waveTop"][-1];
float priorBarValue= dmm->mw["o_s_waveTop"][-2]; //can do upto -300; and even more...these are safe functions that clamp to the extremes if the value is beyond the limits