# Het maken van extra plugins

&kst; heeft een eenvoudige en gestandaardiseerde interface waarmee het maken van extra plugins eenvoudiger wordt. Naast het beschrijven van de basisvereisten voor plugins vindt u in de volgende secties hoe u reeds bestaande header-bestanden kunt gebruiken voor het maken van bepaalde typen van plugins.

## Het maken van een eenvoudige plugin

Een plugin voor &kst; bestaat uit twee bestanden—een XML-bestand en een zogenaamde "shared object file".

### Het XML-bestand

Het XML-bestand geeft informatie over de plugin en beschrijft de invoer en de uitvoer ervan. Het volgende is een voorbeeld van een XML-bestand voor een plugin in &kst;:

    <?xml version="1.0" encoding="UTF-8"?>
    <!DOCTYPE Module SYSTEM "file:/Repository/Level2/Soft/ProC/moduledef.dtd">

    <module>

    <intro>
    <modulename name="testplugin"/>    <!-- De naam van de module -->
    <author name="Rick Chern"/> <!-- De naam van de schrijver -->
    <description text="Een testplugin voor mijzelf"/> <!-- Een beschrijving van de module -->
    <version minor="1" major="0"/>  <!-- Het versienummer van de module -->
    <state devstate="release"/>     <!-- De ontwikkelingsstatus van de module (optioneel)-->
    </intro>

    <interface>

    <!--Hier de invoer-->
    <input>
    <table type="float" name="Invoervector 1" descr="De eerste invoervector" />
    </input>

    <input>
    <float name="Invoerscalair 1" descr="De eerste invoerscalair" />
    </input>

    <!--outputs here-->
    <output>
    <table type="float" name="Uitvoervector 1" descr="De eerste uitvoervector" />
    </output>

    <output>
    <float name="Uitvoerscalair 1" descr="De eerste uitvoerscalar" />
    </output>

    </interface>

    </module>

In het algemeen kunt u het bovenstaande voorbeeld gebruiken als een sjabloon en onderdelen ervan aanpassen naar uw wensen. Zoals u in het voorbeeld kunt zien bestaat het XML-bestand uit een `module`-"node". De `module`-node heeft een `intro`-node en een `interface` node. U moet de `intro`-node aanpassen waarbij u het commentaar in het bovenstaande XML-bestand kunt gebruiken als leiddraad. Het is belangrijk dat de `modulename` en het `name`-attribuut van de bijbehorende "shared object file" aan elkaar gelijk zijn.

De `interface`-node geeft een beschrijving van de werkelijke invoer en uitvoer van de plugin. Elke invoer wordt beschreven in een `input`-node en elke uitvoer in een `output`-node. Bij elke invoer of uitvoer moet er een `table`- of een `float`-node worden opgegeven als een "child". Het `type`-attribuut van een `table` moet `"float"` zijn. Merk op dat de volgorde van de invoer en de uitvoer belangrijk is—de volgorde bepaalt de indexwaarden van elke invoer- en uitvoer"array" in de "object file", en wordt in de plugin-interface van &kst; gebruikt voor het tonen van de in- en uitvoervelden.

Als u klaar bent met het XML-bestand bewaart u het als `[modulenaam].xml` waarin `[modulenaam]` gelijk is aan het `name`-attribuut van de `modulename`-node.

### De "Shared Object File"

De "shared object file" bevat de feitelijke functionaliteit van de plugin. In andere woorden: deze bepaalt hoe de uitvoer wordt verkregen uit de gegeven invoer. De shared object file moet aan de volgende eisen voldoen:

- Het object moet de volgende "C linkage symbol" exporteren:

      int symbol(const double *const inArrays[],
                 const int inArrayLens[],
                 const double inScalars[],
                 double *outArrays[],
                 int outArrayLens[],
                 double outScalars[])

  waarin `symbol` gelijk moet zijn aan het `name`-attribuut van de `modulename`-node in het XML-bestand. Dit is de enige functie die door &kst; wordt aangeroepen (call) (hoewel u andere functies kunt hebben). In het volgende een beschrijving van elk argument van deze functie:

  `const double *const inArrays[]`

- De "array" van invoer-"arrays". Elke invoer-array hoort bij een invoervector. De arrays hebben dezelfde volgorde als de in het XML-bestand genoemde vectoren, zodat `inArrays[0]` de array is die de eerste invoervector vertegenwoordigt, `inArrays[1]` de array die de tweede invoervector vertegenwoordigt, en zo verder.

`const int inArraysLens[]`

- De array met de arraylengtes van elke invoer-array. De lengtes worden in dezelfde volgorde opgeslagen als de arrays in `inArrays[]` (bijv. `inArrayLens[0]` is de lengte van `inArrays[0]`).

`const double inScalars[]`

- De array van invoerscalairen. De scalairen worden in dezelfde volgorde opgeslagen als in het XML-bestand.

`double *outArrays[]`

- De array van uitvoer-arrays. Elke uitvoer-array hoort bij een uitvoervector, en de arrays moeten dezelfde volgorde hebben als de uitvoervectoren in het XML-bestand.

`int outArrayLens[]`

- Deze array moet de lengtes bevatten van de uitvoer-arrays. De volgorde van de lengtes moet dezelfde zijn als die van de arrays in `outArrays[]`.

`double outScalars[]`

- De array van de uitvoerscalairen. De volgorde van de scalairen moet gelijk zijn aan die in het XML-bestand.

- De functie moet `0` retourneren indien met succes uitgevoerd, en anders `-1`.

- In de code van de "object file" moet een onverwachte invoer goed worden verwerkt, zoals lege invoer-arrays (meestal is het in dergelijke gevallen voldoende `-1` te retourneren).

- Het aantal en type van de uitvoer moet precies overeenkomen met die in het XML-bestand.

- Het zal waarschijnlijk nodig zijn de afmetingen van de arrays in `outArrays[]` te wijzigen. Hiervoor kunt u de functie `realloc()` gebruiken. Bijv.:

      outArrays[0]=(double*)realloc(outArrays[0], 5*sizeof(double));

  zal (geheugen)ruimte voor 5 "doubles" aan `outArrays[0]` beschikbaar stellen (allocate). Gebruik voor het toewijzen van geheugen geen andere functie dan `realloc()`.

- De invoerargumenten moeten constanten blijven. Verander (cast) die niet naar niet-constante typen.

Hier volgt een voorbeeld van de broncode voor de shared object file van een eenvoudige plugin:

    #include <stdlib.h>

    extern "C" int testplugin(const double *const inArrays[], const int inArrayLens[],
                    const double is[],
                    double *outArrays[], int outArrayLens[],
                    double outScalars[]);

    int testplugin(const double *const inArrays[], const int inArrayLens[],
                    const double is[],
                    double *outArrays[], int outArrayLens[],
                    double outScalars[])

    //Accepteer 1 vector en 1 scalair. Vermenigvuldig alle elementen van de vector met de
    //scalair, en voer de resulaatvector uit. Voor ook de originele scalair uit.
    {
            //De uitvoer instellen
            outArrayLens[0]=inArrayLens[0];

            //afmetingen wijzigen uitvoer-arrays
            outArrays[0]=(double*)realloc(outArrays[0], inArrayLens[0]*sizeof(double));

            //elk element van de invoervector vermenigvuldigen
            //met de scalair
            for (int i=0; i<inArrayLens[0]; i++)
            {
                    outArrays[0][i]=inArrays[0][i] * is[0];
            }

            //nu de uitvoerscalair instellen
            outScalars[0]=is[0];

            return 0;
    }

### De plugin compileren

Als u voor het compileren van uw plugin &gcc; gebruikt kunt u het objectbestand eenvoudig compileren met:

    cc -Wall -c -o mijnplugin.o mijnplugin.c -fPIC -DPIC

en daarna de gedeelde bibliotheek maken:

    ld -o mijnplugin.so -shared mijnplugin.o

Het zo verkregen `*.so`-bestand en `*.xml`-bestand moeten in dezelfde map worden geplaatst. Wanneer u wilt dat de pluginbeheerder (Plugin Manager) van &kst; het XML-bestand inleest, zal die automatisch in dezelfde map naar de shared object file zoeken.

## Het maken van plugins voor lineaire aanpassing (linear fit)

Om een plugin te maken voor lineaire aanpassing kunt u uw eigen aanpassingsalgoritmen gebruiken en de geëigende vectoren uitvoeren. In &kst; zijn echter reeds de nodige header-bestanden beschikbaar die het voor u eenvoudig maken om plugins te implementeren voor de lineaire aanpassing met behulp van de methode van de kleinste kwadraten, gewoon door u een paar functies ter beschikking te stellen. In deze sectie leest u hoe u deze bestanden kunt gebruiken.

### Header-bestanden

Voor lineaire aanpassing zijn twee header-bestanden aanwezig, `linear.h` (voor ongewogen lineaire aanpassing) en `linear_weighted.h` (voor gewogen lineaire aanpassing). U kunt beiden vinden in de map`kst/plugins/fits/` in de "tarball" (ingepakt archiefbestand met extensie .tar.gz) met de broncode van &kst;. Om deze bestanden te gebruiken moet een ervan worden opgenomen (include) in de broncode van uw plugin:

    #include <../linear.h>

of

    #include <../linear_weighted.h>

(volgens afspraak plaatsen we de broncode voor de plugin in een submap van de map met de header-bestanden).

### Implementeren van de vereiste functies

Gegeven is een algemeen lineair model:

met `y` een vector van `n` waarnemingen, `X` een `n` bij `p` matrix van onafhankelijke variabelen (voorspellers, predictors) en `c` de vector van`p` aan te passen parameters. De header-bestanden verschaffen de functies voor het afschatten van c voor een gegeven `y` en `X`. Voor het verkrijgen van `X` moet de volgende functie worden geïmplementeerd in de broncode van de plugin:

    double calculate_matrix_entry( double dX, int iPos )

Deze functie moet de waarde van de "entry" (ingang) retourneren in de kolom `iPos` van de matrix van onafhankelijke variabelen (predictors, voorspellers), met gebruik van de `x`-waarde `dX`. Deze functie wordt aangeroepen (call) door linear.h of linear_weighted.h. De implementatie van de functie is afhankelijk van het het model dat u voor de aanpassing wilt gebruiken, en is uniek voor elke plugin voor lineaire aanpassing. Bijvoorbeeld, voor de aanpassing aan een veelterm-model kan `calculate_matrix_entry` als volgt worden geïmplementeerd:

    double calculate_matrix_entry( double dX, int iPos ) {
      double dY;
      dY = pow( dX, (double)iPos );
      return dY;
    }

### Het aanroepen (calling) van de aanpassingsfuncties (fitting functions)

Als het goede headerbestand "included" is en `calculate_matrix_entry` is geïmplementeerd kunt u de aanpassingsfunctie die in het header-bestand aanwezig is aanroepen:

    kstfit_linear_unweighted( inArrays, inArrayLens,
                              outArrays, outArrayLens,
                              outScalars, iNumParams );

of

    kstfit_linear_weighted( inArrays, inArrayLens,
                            outArrays, outArrayLens,
                            outScalars, iNumParams );

Elke functie retourneert bij een succesvolle uitvoering `0` en als er een fout optreedt `-1`, het is dus een goed idee om de retourwaarde van de geëxporteerde C-functie gelijk te maken aan die van de aanpassingsfunctie. Voor de eenvoud kan de code voor de plugin de argumenten van de geëxporteerde C-functie gewoon doorgeven aan de aanpassingsfunctie. Maar let erop dat inArrays de volgende structuur moet hebben:

- `inArrays[0]` moet de array van x-coördinaten bevatten van de gegeven punten

- `inArrays[1]` moet de array van y-coördinaten bevatten van de gegeven punten

- `inArrays[2]` bestaat alleen als`kstfit_linear_weighted` wordt aangeroepen, en moet de array van gewichten bevatten die bij de aanpassing worden gebruikt.

De gemakkelijkste manier om er voor te zorgen dat de structuur van inArray in orde is, is het in de goede volgorde opgeven van de invoervectoren in het XML-bestand van de plugin.

`iNumParams` is het aantal van de parameters in het gebruikte aanpassingsmodel en moet gelijk zijn aan het aantal kolommen in de matrix `X` van onafhankelijke variabelen. `iNumParams` moet de juiste waarde hebben voordat de aanpassingsfunctie wordt aangeroepen.

Na het aanroepen van `kstfit_linear_unweighted` of `kstfit_linear_weighted` krijgen `outArrays` en `outScalars` de volgende waarden:

- `outArrays[0]` bevat dan de array van aangepaste y-waarden.

- `outArrays[1]` bevat dan de array van restwaarden (residuen).

- `outArrays[2]` bevat dan de array van de geschatte parameters voor de beste aanpassing (best-fit parameters).

- `outArrays[3]` bevat dan de covariantiematrix, rij na rij in een array geretourneerd.

- `outScalars[0]` bevat dan chi^2/nu, met chi^2 de gewogen som van de kwadraten van de restwaarden, en nu het aantal vrijheidsgraden.

`outArrayLens` bevat dan de lengten van elke uitvoer-array.

Zorg ervoor dat de opgegeven uitvoer in het XML-bestand overeenkomt met de uitvoer die door de geëxporteerde C-functie wordt geretourneerd (wat in de meeste gevallen gewoon de uitvoer is die door de aanpassingsfunctie wordt geretourneerd).

### Voorbeeld

Hier volgt een voorbeeld van de broncode voor een plugin voor een lineaire aanpassing (linear fit).

    /*
     *  Veelterm aanpassingsplugin voor KST.
     *  Copyright 2004, The University of British Columbia
     *  Beschikbaar onder de GPL-voorwaarden.
     */

    #include "../linear.h"

    double calculate_matrix_entry( double dX, int iPos ) {
      double dY;

      dY = pow( dX, (double)iPos );

      return dY;
    }

    extern "C" int kstfit_polynomial_unweighted(
      const double *const inArrays[],
      const int inArrayLens[],
      const double inScalars[],
      double *outArrays[], int outArrayLens[],
      double outScalars[]);

    int kstfit_polynomial_unweighted(
      const double *const inArrays[],
      const int inArrayLens[],
            const double inScalars[],
            double *outArrays[], int outArrayLens[],
            double outScalars[])
    {
      int iRetVal = -1;
      int iNumParams;

      iNumParams = 1 + (int)floor( inScalars[0] );
      if( iNumParams > 0 ) {
        iRetVal = kstfit_linear_unweighted( inArrays, inArrayLens,
                                            outArrays, outArrayLens,
                                            outScalars, iNumParams );
      }

      return iRetVal;
    }

## Het maken van plugins voor niet-lineaire aanpassing (non-linear fit)

&kst; heeft header-bestanden die het maken van plugins voor een niet-lineaire kleinste kwadraten-aanpassing (non-linear least squares fit) vereenvoudigen. In de volgende secties vindt u een beschrijving van het gebruik van deze header-bestanden.

### Header-bestanden en definities

Voor niet-lineaire aanpassing zijn twee header-bestanden aanwezig, `non-linear.h` (voor ongewogen niet-lineaire aanpassing) en `non-linear_weighted.h` (voor gewogen niet-lineaire aanpassing). U kunt beiden vinden in de map`kst/plugins/fits_nonlinear/` in de "tarball" (ingepakt archiefbestand met extensie .tar.gz) met de broncode van &kst;. Om deze bestanden te gebruiken moet een ervan worden opgenomen (include) in de broncode van uw plugin:

    #include <../non-linear.h>

of

    #include <../non-linear_weighted.h>

(volgens afspraak plaatsen we de broncode voor de plugin in een submap van de map met de header-bestanden).

Omdat het niet-lineair aanpassen een iteratief (herhaald) proces is moet u ook het maximum aantal iteraties opgeven. Het algoritme voor de niet-lineaire aanpassing stopt als er aan minstens een van de volgende condities wordt voldaan:

- Het maximum aantal iteraties (herhalingen) is bereikt.

- Een nauwkeurigheid van 10-4 is bereikt.

Bovendien moet u het aantal parameters in het model opgeven omdat die niet expliciet wordt doorgegeven naar de aanpassingsfunctie. Om deze twee waarden op te geven neemt u die op bovenin uw broncode:

    #define NUM_PARAMS [num1]
    #define MAX_NUM_ITERATIONS [num2]

waarbij u `[num1]` vervangt door het aantal parameters in het model en `[num2]` door het maximale aantal iteraties.

### Implementeren van de vereiste functies

Om de header-bestanden te gebruiken voor niet-lineaire aanpassing moet u de te gebruiken functie leveren voor het model, de partiële afgeleiden van de functie naar elke parameter en de geschatte beginwaarden voor de aan te passen parameters. Om dit te doen moeten er drie functies worden geïmplementeerd. Deze functies worden hieronder beschreven.

`double function_calculate( double `dX`, double* `pdParameters` )`

- Deze functie berekent de y-waarde van het aanpassingsmodel voor een gegeven x-waarde `dX` met gebruik van de opgegeven array van parameters `pdParameters`. De volgorde van de parameters in `pdParameters` is willekeurig maar moet wel kloppen met de andere twee geïmplementeerde functies. Bijvoorbeeld, voor een exponentieel model kan `function_calculate` als volgt worden geïmplementeerd:

      double function_calculate( double dX, double* pdParameters ) {
        double dScale         = pdParameters[0];
        double dLambda = pdParameters[1];
        double dOffset = pdParameters[2];
        double dY;

        dY  = ( dScale * exp( -dLambda * dX ) ) + dOffset;

        return dY;
      }

`void function_derivative( double `dX`, double* `pdParameters`, double* `pdDerivatives` )`

- Deze functie berekent de partiële afgeleide waarden van de modelfunctie voor een gegeven x-waarde `dX`. De partiële afgeleide waarden moeten worden geretourneerd in `pdDerivatives`. De volgorde van de partiële afgeleide waarden in `pdDerivatives` moet overeenstemmen met de volgorde van de parameters in `pdParameters` (bijv. als `pdParameters[0]` de parameter lambda bevat van een exponentieel model moet `pdDerivatives[0]` de afgeleide waarde bevatten van het model naar lambda).

`void function_initial_estimate( const double* `pdX`, const double* `pdY`, int `iLength`, double* `pdParameterEstimates` )`

- Deze functie levert een eerste afschatting voor de best passende parameters van de aanpassingsfunctie. De arrays van x- en y-waarden van de gegeven punten worden gegeven in `pdX` en `pdY`, en het aantal gegeven punten in `iLength`. Het is aan u of u die al of niet gebruikt voor de berekening van de beginwaarden. De functie moet de berekende beginwaarden plaatsen in `pdParameterEstimates`, waarbij de volgorde overeen moet komen met die van de parameters in `pdParameters` van `function_calculate` en `function_derivative`. Vergeet niet dat de beginwaarden belangrijk zijn voor het al of niet convergeren naar een oplossing van de aanpassingsfunctie.

### Het aanroepen (calling) van de aanpassingsfuncties (fitting functions)

Als de vereiste functies zijn geïmplementeerd, kan de aanpassingsfunctie in het header-bestand worden aangeroepen:

    kstfit_nonlinear( inArrays, inArrayLens,
                      inScalars, outArrays,
                      outArrayLens, outScalars );

of

    kstfit_nonlinear_weighted( inArrays, inArrayLens,
                               inScalars, outArrays,
                               outArrayLens, outScalars );

afhankelijk van of u een ongewogen of gewogen aanpassing wilt.

De functie retourneert bij succes `0` of `-1` als er een fout optreedt, dus is het het eenvoudigst als de retourwaarde van de geëxporteerde C-functie gelijk wordt gesteld aan de retourwaarde van de aanpassingsfunctie. Voor de eenvoud kan de code van de plugin gewoon de argumenten van de geëxporteerde C-functie doorgeven aan de aanpassingsfunctie. Maar let erop dat inArrays als volgt moet worden gestructureerd:

- `inArrays[0]` moet de array van x-coördinaten bevatten van de gegeven punten

- `inArrays[1]` moet de array van y-coördinaten bevatten van de gegeven punten

- `inArrays[2]` bestaat alleen als`kstfit_linear_weighted` wordt aangeroepen, en moet de array van gewichten bevatten die bij de aanpassing worden gebruikt.

De gemakkelijkste manier om er voor te zorgen dat de structuur van inArray in orde is, is het in de goede volgorde opgeven van de invoervectoren in het XML-bestand van de plugin.

Na het aanroepen van `kstfit_linear_unweighted` of `kstfit_linear_weighted` krijgen `outArrays` en `outScalars` de volgende waarden:

- `outArrays[0]` bevat dan de array van aangepaste y-waarden.

- `outArrays[1]` bevat dan de array van restwaarden (residuen).

- `outArrays[2]` bevat dan de array van de geschatte parameters voor de beste aanpassing (best-fit parameters).

- `outArrays[3]` bevat dan de covariantiematrix, rij na rij in een array geretourneerd.

- `outScalars[0]` bevat dan chi^2/nu, met chi^2 de gewogen som van de kwadraten van de restwaarden, en nu het aantal vrijheidsgraden.

`outArrayLens` bevat dan de lengten van elke uitvoer-array.

Zorg ervoor dat de opgegeven uitvoer in het XML-bestand overeenkomt met de uitvoer die door de geëxporteerde C-functie wordt geretourneerd (wat in de meeste gevallen gewoon de uitvoer is die door de aanpassingsfunctie wordt geretourneerd).

### Voorbeeld

Het volgende is een voorbeeld van een niet-lineaire aanpassingsplugin voor een aanpassing (fit) aan een exponentieel model:

    /*
     *  Exponentiële aanpassingsplugin voor KST.
     *  Copyright 2004, The University of British Columbia
     *  Beschikbaar onder de GPL-voorwaarden.
     */

    #define NUM_PARAMS 3
    #define MAX_NUM_ITERATIONS 500

    #include "../non_linear.h"

    void function_initial_estimate( const double* pdX, const double* pdY,
                                    int iLength, double* pdParameterEstimates ) {
      KST_UNUSED( pdX )
      KST_UNUSED( pdY )
      KST_UNUSED( iLength )

      pdParameterEstimates[0] =  1.0;
      pdParameterEstimates[1] =  0.0;
      pdParameterEstimates[2] =  0.0;
    }

    double function_calculate( double dX, double* pdParameters ) {
      double dScale         = pdParameters[0];
      double dLambda = pdParameters[1];
      double dOffset = pdParameters[2];
      double dY;

      dY  = ( dScale * exp( -dLambda * dX ) ) + dOffset;

      return dY;
    }

    void function_derivative( double dX, double* pdParameters, double* pdDerivatives ) {
      double dScale         = pdParameters[0];
      double dLambda = pdParameters[1];
      double dExp;
      double ddScale;
      double ddLambda;
      double ddOffset;

      dExp     = exp( -dLambda * dX );
      ddScale  = dExp;
      ddLambda = -dX * dScale * dExp;
      ddOffset = 1.0;

      pdDerivatives[0] = ddScale;
      pdDerivatives[1] = ddLambda;
      pdDerivatives[2] = ddOffset;
    }

    extern "C" int kstfit_exponential(const double *const inArrays[], const int inArrayLens[],
                    const double inScalars[],
                    double *outArrays[], int outArrayLens[],
                    double outScalars[]);

    int kstfit_exponential(const double *const inArrays[], const int inArrayLens[],
                    const double inScalars[],
                    double *outArrays[], int outArrayLens[],
                    double outScalars[])
    {
      return kstfit_nonlinear( inArrays, inArrayLens,
                               inScalars, outArrays,
                               outArrayLens, outScalars );
    }

## Het maken van plugins voor doorlaatfilters

&kst; heeft header-bestanden waardoor het implementeren van doorlaatfilters wordt vereenvoudigd. Hieronder wordt het gebruik van deze header-bestanden beschreven.

### Header-bestanden

Het header-bestand voor doorlaatfilters bevindt zich in de map `kst/plugins/pass_filters` van de "tarball" (ingepakt archiefbestand met extensie .tar.gz) van de broncode van &kst;. Het bestand heet `filters.h`. Om dit bestand te gebruiken neemt u het op (include) in de broncode van uw plugin:

    #include <../filters.h>

(volgens afspraak plaatsen we de broncode voor de plugin in een submap van de map met de header-bestanden).

### Vereiste functies

Het header-bestand `filters.h` bevat een enkele functie die de Fouriertransformatie berekent van een aangeleverde functie, het geleverde filter toepast op de Fouriertransformatie, en daarna de inverse Fouriertransformatie berekent van de gefilterde Fouriertransformatie. Om het filter te leveren moet de volgende functie worden geïmplementeerd in de broncode van uw plugin:

`double filter_calculate( double `dFreqValue`, const double `inScalars[]` )`

Deze functie moet de gefilterde amplitude berekenen voor de frequentie `dFreqValue`. `inScalars[]` bevat dan de ongewijzigde invoerscalairen van de plugin die zijn opgegeven in het XML-bestand. Hoogstwaarschijnlijk zal `inScalars[]` de afkapfrequenties of andere eigenschappen bevatten van het filter. Bijvoorbeeld, voor het implementeren van het Butterworth hoogdoorlaatfilter kan de functie `filter_calculate` als volgt worden geïmplementeerd:

    double filter_calculate( double dFreqValue, const double inScalars[] ) {
      double dValue;
      if( dFreqValue
    > 0.0 ) {
        dValue = 1.0 / ( 1.0 +
                        pow( inScalars[1] / dFreqValue, 2.0 * (double)inScalars[0] ) );
      } else {
        dValue = 0.0;
      }
      return dValue;
    }

### Het aanroepen (calling) van de filterfunctie

Als de nodige `filter_calculate` is geïmplementeerd kan de filterfunctie in het header-bestand als volgt worden aangeroepen:

    kst_pass_filter( inArrays,
                     inArrayLens,
                     inScalars,
                     outArrays,
                     outArrayLens,
                     outScalars );

De argumenten voor de geëxporteerde C-functie kunnen gewoonlijk zonder wijzigingen aan `kst_pass_filter` worden doorgegeven. Echter, er zijn een paar beperkingen voor de argumenten:

- `inArrays[0]` moet de array van te filteren gegevens bevatten.

- `inScalars` moet de door de functie `filter_calculate` te gebruiken parameters bevatten die eigen zijn aan het filter.

Na het aanroepen van de functie bevat `outArrays[0]` de array van gefilterde gegevens en zal `outArrayLens` daaraan zijn aangepast. De functie `kst_pass_filter` maakt geen gebruik van `outScalars`.

### Voorbeeld

Het volgende is een voorbeeld van een plugin voor een Butterworth hoogdoorlaatfilter:

    /*
     *  Butterworth hoogdoorlaatfilter plugin voor KST.
     *  Copyright 2004, The University of British Columbia
     *  Beschikbaar onder de GPL-voorwaarden.
     */

    #include <stdlib.h>
    #include <math.h>
    #include "../filters.h"

    extern "C" int butterworth_highpass(const double *const inArrays[], const int inArrayLens[],
                    const double inScalars[],
                    double *outArrays[], int outArrayLens[],
                    double outScalars[]);

    int butterworth_highpass(const double *const inArrays[], const int inArrayLens[],
                    const double inScalars[],
                    double *outArrays[], int outArrayLens[],
                    double outScalars[])
    {
      int iReturn;

      iReturn = kst_pass_filter( inArrays,
                                 inArrayLens,
                                 inScalars,
                                 outArrays,
                                 outArrayLens,
                                 outScalars );

      return iReturn;
    }

    double filter_calculate( double dFreqValue, const double inScalars[] ) {
      double dValue;

      if( dFreqValue > 0.0 ) {
        dValue = 1.0 / ( 1.0 + pow( inScalars[1] / dFreqValue, 2.0 * (double)inScalars[0] ) );
      } else {
        dValue = 0.0;
      }

      return dValue;
    }