Normalized Power fomula by garmin

I do no see the change on your formula if you are doing 200 avg30 raised to ^4 is 1600000000 and raised to ^25 is again 200

First you take the average of power over 30 seconds and raise that that to the power of 4.

Then you take the average of the above over the entire activity and raise that to the power of 0.25.

Like you said, it makes no difference if your power is just 200 all the time. 

In reality, your power will be changing throughout the whole activity; the idea of NP is to smooth the data using the 30 s moving average.

https://science4performance.com/2017/04/20/strava-ride-statistics/

So your numbers file implements the following formula:

Average(Average(Power^4)) ^ 0.25

Sure, that's not the same as average power, but it's not normalized power either. Your formula just gives more weight to higher values of Power.

The proper formula is still:

Average(RollingAverage(Power, 30 seconds)) ^ 4) ^ 0.25

I don't see why you can't apply the proper formula. Monkey C is a Turing-complete programming language, so it can implement *anything* given enough memory and CPU time. For this function you just need to store about 32 values in memory, give or take.

I also don't see what calculating / displaying 30AVG in a different field has to do with not being able to calculate NP. You can calculate either one or both, regardless.

For the purposes of this pseudo-code, I'm going to assume that normalized power should be undefined / null for the first 30 seconds of the activity.

class FixedSizeQueue() {
    function initialize(max_size) {
        // create queue with max_size elements
        // TODO...
    }

    function enqueue(x) {
        // insert x at back of queue
        // TODO...
        // if current queue size > max_size, remove front item from queue
        // TODO...
    }

    // ^ This can implemented with a fixed length array and two
    // indexes which point to the first and last items in the 
    // queue

    function size() {
        // return the current size of queue
        // TODO...
    }
}

class RollingAverage() {
    var fixedSizeQueue;
    var size;
    function initialize(s) {
        size = s;
        fixedSizeQueue = new FixedSizeQueue(size);
    }

    function addData(x) {
        fixedSizeQueue.enqueue(x);
        // fixedSizeQueue only holds up to size elements
        // If more elements are added, the oldest elements drop off
    }

    function getAvg() {
        if (fixedSizeQueue.size() < size) {
            return null;
        } else {
            // return average of all elements in fixedSizeQueue
            // TODO...
        }
    }
}

class NormalizedPower() {
    var numSamples;
    var rolling_power_data;
    var average_rolling_power_4;
    function initialize() {
        rolling_power_data = new RollingAverage(30);
        average_rolling_power_4 = 0;
        numSamples = 0;
    }

    // compute() takes the current power as an argument
    // and returns either null or the calculated normalized power 
    // Assumption: this function is called once per second
    function compute(currentPower) {
        rolling_power_data.addData(currentPower);

        var rolling_power = rolling_power_data.getAvg();
        if (rolling_power == null) {
            return null;
        }

        numSamples++;
        var rolling_power_4 = Math.pow(rolling_power, 4);

        average_rolling_power_4 = (average_rolling_power_4 * (numSamples-1) + (rolling_power_4)) / numSamples;

        return Math.pow(average_rolling_power_4, 0.25);
    }
}


class NpView extends Ui.SimpleDataField {
    var np;
    // init program
    function initialze() {
        np = new NormalizedPower();
    }

    // Assume compute() is called once per-second by the CIQ framework
    function compute(activityInfo) {
        var currentPower = activityInfo.currentPower;
        var currentNP = np.compute(currentPower);

        if (currentNP == null) {
            return "--";
        }

        return currentNP;
    }
}

THANKS A LOT!!

im using this

if (avTime > 30){

NP = ((NP + ((30AVGr^4) - NP) / avTime))^.25.toNumber();

}

I think is working

I think the problem was you need to wait for 30 seconds until calculation, other way normalized power is lower than average

FlowState wrote:

"Garmin Connect IQ data fields give you updated data roughly once per second (in the onUpdate() function), so you just save a sample every time onUpdate() is called. Personally, I would think of each sample as an *instantaneous* power value, not an average.

In an "device app", you could schedule onUpdate() to run every second.

Either way, you're basically sampling once per second. Sure, if you could sample more than once per second, you could have "better" data. Hypothetically, if you could sample 10 times per second, then your data set for the 30-second rolling average would contain 300 values.

Since we're probably talking about a data field here, the sample frequency is once per second and the math is easy."

________________

Thanks for your thoughts.

I also think that one value per second should be enough, as a matter of fact the difference of taking:

- only one value per second as one extreme

- the whole integral over one second as another extreme

will be quite marginal in the NP value in the end.

You're welcome!

But are you sure this is right?

NP = ((NP + ((30AVGr^4) - NP) / avTime))^.25.toNumber();

I don't think you can calculate the "average of 30AVGr^4" using NP, because is NP is avg(30AVGr^4) ^ .25.

You could use NP^4 which should be the same as "average of 30AVGr^4": e.g.

NP = ((NP^4 * (time-1) + 30AVGr^4) / time))^.25

Or just do what I did above and use the avg 30AVGr^4 instead of NP as the "stored value" for the calculation at t + 1:

avg_smoothed_power_4 = (avg_smoothed_power_4 * (time-1) + 30AVGr^4) / time
NP = avg_smoothed_power_4 ^ 0.25

thanks a lot both formulas give the same number, in fact 3 of them i tested in different ways the number is different than avgPower what worries me it´s that in most of the cases the number is lower than general avgPower maybe it´s because it need more samples or maybe it´s because my general avgPower it´s not including zeros and 30AVG yes.

Well, I'm fairly sure that my formula and your formula are not mathematically equivalent. Just because they give the same or similar results for a given data set doesn't really prove anything. Like you pointed out, if your power is just 200 all the time, then your avg power and NP will both be 200.

Your strategy for including zeros should def be consistent for average power and 30s rolling average power. Not sure why you would want them to be different.

You should try running generating a FIT file with power in the simulator for about 10-20 minutes, and run both of our formulas on it. I'm pretty sure they'll give different results.

Of the two options I presented, I would personally go with:

avg_smoothed_power_4 = (avg_smoothed_power_4 * (time-1) + 30AVGr^4) / time
NP = avg_smoothed_power_4 ^ 0.25

The other option (using NP^4 in the calculation) is slightly worse because of any issues with rounding/floating point errors due to applying ^0.25 and ^4 unnecessarily to the intermediate "avg smoothed power ^ 4" value.

To answer your question about why NP is lower than avg power, it's because it's not really considered valid for intervals shorter than 20 minutes.

https://help.trainingpeaks.com/hc/en-us/articles/218243287-Why-is-my-normalized-power-lower-than-my-average-power-

now it´s implemented i used this avg_smoothed_power_4 = (avg_smoothed_power_4 * (time-1) + 30AVGr^4) / time

i think is working as i understand it need a lot of samples thanks a lot!!!

help.trainingpeaks.com/.../218243287-Why-is-my-normalized-power-lower-than-my-average-power-