I have a class of signals described by function: $$ f(inc,d,t)=inc\cdot t^d $$ where inc and d have a finite set of values like 1, 2, 3, i.e. $$ inc, d\in \left \{1,2,3 \right \} $$ and $$ 0\leq t<1 $$

Example plots:

f(inc,d,t) plot

I need to determine parameters inc and d given a discrete signal of f obscured by additive white Gaussian noise. Preferably an algorithm capable of working at real time.

Some candidates are:

  • sole differentiation (this amplifies noise)
  • filtering + differentiation (loses information)
  • curve fitting (least squares?)

Polynomial fitting seems to be an overkill, because function is known and is monotonic. Isotonic regression seems too general, because it is applicable to all increasing/decreasing functions. Maybe there is a better solution when we have a concrete function and a set of possible parameters.

  • $\begingroup$ Are the discrete time points regularly spaced? How many points at typically sampled in $[0,\,1]$. $\endgroup$ Commented Oct 8, 2020 at 19:20
  • $\begingroup$ Yes, they are regularly spaced. I'm currently experimenting with about 1000 samples per $[0, 1]$ interval, although it may be less (about 50-100 of samples). $\endgroup$
    – PSz
    Commented Oct 8, 2020 at 19:28
  • $\begingroup$ I am truly interested in the "real-word" or physical motivation of your question. Could you share it? $\endgroup$ Commented Oct 8, 2020 at 20:26
  • $\begingroup$ Compression and polynomials? My two first loves, I like that $\endgroup$ Commented Oct 8, 2020 at 20:40

2 Answers 2


Since your domain for the parameters is limited (Only 9 options) the best way for White Noise would be going through them and pick then one with the least Mean Squared Error (MSE) which is the parameter to minimize for AWGN.

in MATLAB it will be something like:

function [ paramAlpha, paramBeta ] = EstimateModelParameters( vT, vY )

vParamAlpha = [1, 2, 3];
vParamBeta  = [1, 2, 3];

bestMse = 1e50;

vX = zeros(size(vY, 1), 1, class(vY));

for ii = 1:length(vParamAlpha)
    currParamAlpha = vParamAlpha(ii);
    for jj = 1:length(vParamBeta)
        currParamBeta = vParamBeta(jj);
        vX(:) = currParamAlpha * (vT .^ currParamBeta);
        currMse = mean((vX - vY) .^ 2);
        if(currMse < bestMse)
            bestMse     = currMse;
            paramAlpha  = currParamAlpha;
            paramBeta   = currParamBeta;


In a simple performance simulation I got the following:

enter image description here

Which means that for STD in reasonable value for this case (Since your maximum value is around ~3) your performance will be great.

The code is easily adaptable to any values of the parameters you'd like.
Though I think such brute force methods are reasonable for up to ~100 combinations.

Another thing you might try is use Affine Model on the log of the values. Then apply some "Rounding" to the values. Though this will change the properties of the noise, in real world it seems to be effective way.

The full code is available on my StackExchange Signal Processing Q70753 GitHub Repository (Look at the SignalProcessing\Q70753 folder).


To me polynomial fitting is not overkill, as it uses the maximal knowledge on the data. A monic polynomial (only one $x^\delta$ term) could be a good approach, especially with robust regression, for maximum noise resistance. If $\mathrm{inc}$ and $d$ are in moderate-size finite subsets, performing all combinations and choosing the best of all (with an appropriate metric) would be a way to go.

You can also perform a logarithmic transformation, impose constraints on coefficients.

Question :

  • are all unknowns supposed to be integers?

PS : I may come back later with simulations.

  • 1
    $\begingroup$ Thank you for answering my question. I come from a programmer background with basic DSP experience rather than mathematical one. Curve or polynomial fitting methods are entirely new to me. I thought that polynomials may have multiple inflection points so it could be a bit too general for such a simple function as f. To answer your question, I can choose unknowns by myself so they may be integers, however inc would rather be a number that is integer multiple of some constant (not necessary an integer), where the multiple has finite possibilities (like 1,2,3) $\endgroup$
    – PSz
    Commented Oct 8, 2020 at 17:48
  • $\begingroup$ Polynomials do have inflection points, yet with low degree and advanced optimization, this can be mitigated, for mild noises $\endgroup$ Commented Oct 8, 2020 at 19:17

Your Answer

By clicking “Post Your Answer”, you agree to our terms of service and acknowledge you have read our privacy policy.

Not the answer you're looking for? Browse other questions tagged or ask your own question.