Finding running low - c++

Question

I have a vector of structs containing the following type of variables:
Date Time Low
11/1/17 929 74.25
11/1/17 930 73
11/1/17 931 75
11/1/17 932 70
etc.
I now want to add another struct to my vector called "LowRun", where LowRun is the smallest low at every point in the iteration, like so:
Date Time Low LowRun
11/1/17 929 74.25 74.25
11/1/17 930 73 73
11/1/17 931 75 73
11/1/17 932 70 70
This is what I've tried so far, but this is not giving the right output:
edited:
int CalcLow_SoFar(std::vector<PriceInfo>& p)
double running_low = p[0].Low;
for (size_t i = 1; i < p.size(); ++i)
{
if (p[i].Time > 929
&& p[i].Time < 1601
&& p[i].Date == p[i - 1].Date)
{
if (p[i].Low < running_low)
{
running_low = p[i].Low;
p[i].LowRun = running_low;
}
}
}
return 0;
}
Can you help me get unstuck, thank you!

Answer 1

You've got several weird logic problems in your code, so I'm just going to list them here.
This if statement makes no sense: if (p[i].Low < p[i-1].Low). You assign running_low to the current value whenever the current value is less than the previous value. However, it's perfectly possible for the value to decrease while not being lower than the running low. For example, if you have the sequence 1, 3, 2, the LowRun value at the index 2 gets assigned to 2 because 2 is less than 3, even though the running low should be 1.
The if statement after the one I was talking about (if (p[i+1].Low < running_low)) would have been good if you didn't add 1 to i for some reason. Instead of going from 1 to p.size() - 1, you're now going from 2 to p.size(), so you access one element past the end of the vector which is undefined behavior.
You only assigned the LowRun values when the running_low value changes. This means that if a value didn't change the running low, it's LowRun value is uninitialized which is where the garbage values come from.
You didn't initialize running_low to the first element.
I don't know the details of what you're doing, but the condition checking the time and date looks suspicious, so I've removed it for now. It basically ignores an entry if it's the first one on that day. If that's what you want to do, instead of initializing running_low to the value of the first element, initialize it to something like std::numeric_limits<double>::max() so it's guaranteed to get updated on the first valid entry and change your loop to start from 0.
This doesn't affect the functionality, but unlike main(), other functions you define don't have to return an int or even anything at all. Use void if you don't need the function to return anything.
Lastly, you should get in the habit of using good formatting including proper indents so you don't confuse yourself.
The fixed code:
void CalcLow_SoFar(std::vector<PriceInfo>& p)
{
double running_low = p[0].Low;
p[0].LowRun = p[0].Low;
for (size_t i = 1; i < p.size(); ++i)
{
if (p[i].Low < running_low)
{
running_low = p[i].Low;
}
p[i].LowRun = running_low;
}
}
Version with the date and time checks:
void CalcLow_SoFar(std::vector<PriceInfo>& p)
{
double running_low = std::numeric_limits<double>::max();
for (size_t i = 0; i < p.size(); ++i)
{
if (p[i].Time > 929
&& p[i].Time < 1601
&& i != 0
&& p[i].Date == p[i - 1].Date
&& p[i].Low < running_low)
{
running_low = p[i].Low;
}
p[i].LowRun = running_low;
}
}
Note that for this version, the Low values for the first few elements will be a very large value since a valid entry hasn't been encountered and running_low still holds the value we initialized it to.
Here's the version which only includes the values from the same day in the running low and also ignores any values with a time not in [930, 1600]:
void CalcLow_SoFar(std::vector<PriceInfo>& p)
{
double running_low;
for (size_t i = 0; i < p.size(); ++i)
{
if (i == 0 || p[i].Date != p[i - 1].Date)
{
running_low = std::numeric_limits<double>::max();
}
if (p[i].Time >= 930
&& p[i].Time <= 1600
&& p[i].Low < running_low)
{
running_low = p[i].Low;
}
p[i].LowRun = running_low;
}
}
Similar to the second version in this answer, the LowRun values might be std::numeric_limits<double>::max() if a value in that day within the time limits hasn't been encountered yet.