Feature/yo filtered double

[SylvainBertrand]

Original PR: #197
I had to cherry-pick the actual commits out of the branch.

[conconman]

@SylvainBertrand let me know if there are any ways I could make this more useful or accessible. Ideally, this work can generalize to any type of causal filter, and perhaps it would be more useful if I made some example classes where people wouldn't need to know or setup the transfer function beforehand.

[conconman]

@rjgriffin42 original request was nearly a year ago now lol

[conconman]

@rjgriffin42 1.5 years ago, but I could really use this now

[rjgriffin42]

I would prefer these to be copies, so that this doesn't keep track of the pointer.

[rjgriffin42]

resultingTransferFunction

[rjgriffin42]

Should also be a copy, not a return

[rjgriffin42]

why cascade? why not multiply? At the very least, this should be camelCase, not PascalCase.

I would also say that you should make a static method as:

private static void multiply(ContinuousTransferFunction resultToPack, ContinuousTransferFunction H1, ContinuousTransferFunction H2)
{
    resultToPack.setGain(H1.getGain() * H2.getGain());
    multiplyPolynomial(resultToPack.getNumeratorUnsafe(), H1.getNumerator(), H2.getNumerator());
    multiplyPolynomial(resultToPack.getDenominatorUnsafe(), H1.getDenominator(), H2.getDenominator());
}

Then change the body of this method to:

ContinuousTransferFunction result = new ContinuousTransferFunction();
multiply(result, H1, H2);
return result;

You will also need to then rename the methods getNumerator() and getDenominator() to getNumeratorUnsafe() and getDenominatorUnsafe() to recognize that they're returning a pointer to the object contained in this class.

You also need to add a warning in this javadoc that it is not garbage free.

[rjgriffin42]

rename these methods to **Unsafe() and then add these as

public void getNumerator(double[] numeratorToPack)
{
copy
}

[rjgriffin42]

this should be changed to

private static double[] multiplyPolynomials(double[] poly1, double[] poly2)
{
   double[] result = new double[poly1.length + poly2.length - 1];
   multiply(result, poly1, poly2);
   return result;
}

private static void multiplyPolynomials(double[] resultToPack, double[] poly1, double poly2)
{
      // Cycle through poly1 and poly2 to polynomials.
      for (int i = 0; i < poly1.length; i++)
      {
         for (int j = 0; j < poly2.length; j++)
         {
            result[i + j] += poly1[i] * poly2[j];
         }
      }
}

[rjgriffin42]

and for the first one, you need to add a warning that it allocates and is not garbage free.

[rjgriffin42]

I would make these copy value, rather than store the pointer, so that it doesn't get modified unintentionally.

[rjgriffin42]

Please add some static methods that create transfer functions for generic types. Example,

• createLowPassFilterTransferFunction(double breakFrequency)
• createHighPassFilterTransferFunction(double breakFrequency)
• createNotchFilterTransferFunction(double notchFrequency, double notchWidth)

[rjgriffin42]

can these be final?

[rjgriffin42]

these may need to change, or be direct methods (getNumberOfPoles(), getNumberOfZeroes())

[rjgriffin42]

this.p = 1.0 / (2.0 * sampleFrequency);

[rjgriffin42]

remove line

[rjgriffin42]

this is full of garbage creation. Please fix it. I also have no idea what this method does.

[rjgriffin42]

garbage

[rjgriffin42]

garbage

[rjgriffin42]

garbage

[rjgriffin42]

can you not do a swap operation on the entries of the backing array, instead?

double[] data = inputVector.data;
int lastIndex = inputVector.data.length - 1;
for (int i = 0; i < numCols / 2; i++)
{
    double newStart = inputVector[lastIndex - i];
    inputVector[lastIndex - i] = inputVector[i];
    inputVector[i] = newStart;
}

[rjgriffin42]

You should do a pack operation here instead.

[rjgriffin42]

What is going on here? This doesn't copy, so tempVec is always equal to inputVec, so I'm sure this is doing what you think.

[rjgriffin42]

This should be done in place, so it doesn't generate garbage.

[rjgriffin42]

why would you write it this way, as opposed to 0.5? This does an actual operation, while writing 0.5 doesn't.