ich feile gerade an meiner Bachelorarbeit und habe ein Problem (mal wieder) mit Templates. Es geht um eine "raised cosine" Reihe, die ich mit Templates darstellen möchte. Keine Angst es wird nicht mathematisch, weil es nur um den Code geht.

Die Reihe, die ich brauche ist definiert als:

rcos[t]n[/t](w) = rcos[t]n-1[/t](w) + (-1)[h]n[/h] * a[t]n[/t] * cos(w*n)
rcos[t]0[/t](w) = a[t]0[/t]

Mit anderen Worten ist sie eben iterativ und eine Summe aus n+1 Termen wobei jeder Term a_n*cos(w*n) ist mit abwechselndem Vorzeichen. Der Code sollte sehr performant ablaufen, deshalb wäre es für kleine n schön, die Funktion inline zu haben.

Da ich mich mit Fließkommagenauigkeiten noch nicht beschäftigen möchte ist ohnehin alles mit Templates gelöst worden, sodass ich floats oder doubles nehmen kann. Das Problem für den Compiler entsteht in den Zeilen mit den vielen Ausrufezeichen (C2768). Ich kann mit dem Fehler etwas anfangen, aber ich weiß nicht, wie ich ihn beheben kann. Ich möchte ein Template soweit spezialisieren, dass ein Templateparameter explizit ist und der andere weiterhin dynamisch bleibt, siehe Code unterhalb.

Ich würde mich sehr über Hilfe freuen, damit ich nicht bei der Implementierung weiterer Reihe abklopfen muss. Vielen Dank!

// anyheader.h
template<unsigned int Order, typename Precision>
inline Precision raised_cosine(const Precision w,
	const Precision *a
)
{
	return raised_cosine<Order-1, Precision>(w, a)
		+ a[Order]*cos(w * Order)*((Order&0x1)?-1:1);
}

template<unsigned int Order, typename Precision>
inline Precision raised_cosine(const Precision w,
	const Precision (&a)[Order]
)
{
	return raised_cosine<Order, Precision>(w, (const Precision *)&a);
}

// C2768 !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
template<typename Precision>
inline Precision raised_cosine<0, Precision>(const Precision w,
	const Precision *a
)
{
	return a[0];
}
// !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!

// ----------------------------------------
// Blackman-Harris window
// ----------------------------------------
#define BLACKMANHARRIS_A0 0.35875
#define BLACKMANHARRIS_A1 0.48829
#define BLACKMANHARRIS_A2 0.14128
#define BLACKMANHARRIS_A3 0.01168
// ----------------------------------------
template<typename Precision>
Precision window_blackmanharris(Precision n, Precision N)
{
	const Precision w = n/(N-1) * 2 * M_PI;

	/* old implementation
	return (Precision)BLACKMANHARRIS_A0
		- cos(factor    ) * BLACKMANHARRIS_A1
		+ cos(factor * 2) * BLACKMANHARRIS_A2 
		- cos(factor * 3) * BLACKMANHARRIS_A3;
		*/

	const Precision a[] =
		{ BLACKMANHARRIS_A0, BLACKMANHARRIS_A1,
		BLACKMANHARRIS_A2, BLACKMANHARRIS_A3};

	return raised_cosine<4, Precision>(w, a); // explicit templates
}
// ----------------------------------------

// main.cpp
int main()
{
	std::cout << window_blackmanharris<float>( 3.f, 10.f) << std::endl; // edit cout
}

2.- an deiner stelle, nur um den überblick zu wahren, schreib die template argumente bei den aufrufen hin
->

int main()
{
    cout << window_blackmanharris<float>(3.0f, 10.0f) << endl;
    return 0x0;
}

3.- wenn du schon solche reinen C++ dinge wie templates nutzt, nutz wenigstens auch den rest an c++, sprich in dem fall cout

4.- und die fehlermeldung (jedenfalls die von msvc) besagt, dass der compiler sich die richtige funktion nicht selbst herleiten kann, ich denke, wenn du die template argumente angibst wird der fehler weg sein

Skym0sh0 schrieb:

4.- und die fehlermeldung (jedenfalls die von msvc) besagt, dass der compiler sich die richtige funktion nicht selbst herleiten kann, ich denke, wenn du die template argumente angibst wird der fehler weg sein

Eher nicht.

Habe den Code angepasst, sodass alle Funktionen explizit aufgerufen werden, aber es bleibt nach wie vor der Fehler.
Den Link habe ich mir ebenfalls angeschaut und soweit verstanden "Funktionstemplates lassen sich nicht partiell spezialisieren, nur vollständig und dann werden diese überladen". Die Frage ist nur, warum es so ist. Mein Code ist doch nicht zweideutig?

Wenn sich die Funktionen gegenseitig überladen, dann wären reine Builtins (template<int i>) für Funktionen ja immer Schwachsinn, weil die Signatur(Name + Parametertypen + const/nicht-const) der Methode sich nicht ändert und wenn ich raised_cosine<100> Aufrufe wird die Funktion 100x überschrieben, aber es wird immer nur die letzte überschriebene Funktion aufgerufen, also raised_cosine<0>? Stimmt das so?

Danke für die Antworten.

edit (+code): jetzt scheint die Ausgabe zu stimmen n=0 muss gesondert behandelt werden.

template<typename Precision>
inline Precision raised_cosine(size_t order, const Precision w,
	const Precision *a
)
{
	Precision value = (Precision)0;

	// edited
	while(order-->0)
		value += a[order]*cos(w * order)*((order&0x1)?-1:1);

	return value + a[0];
}

// Aufruf mit festem Array nimmt Arbeit ab
template<size_t Order, typename Precision>
inline Precision raised_cosine(const Precision w,
	const Precision (&a)[Order]
)
{
	return raised_cosine<Precision>(Order, w, (const Precision *)&a);
}

// ----------------------------------------
// Blackman-Harris window
// ----------------------------------------
#define BLACKMANHARRIS_A0 0.35875
#define BLACKMANHARRIS_A1 0.48829
#define BLACKMANHARRIS_A2 0.14128
#define BLACKMANHARRIS_A3 0.01168
// ----------------------------------------
template<typename Precision>
Precision window_blackmanharris(Precision n, Precision N)
{
	const Precision w = n/(N-1) * (Precision)2 * (Precision)M_PI;

	/*
	return (Precision)BLACKMANHARRIS_A0
		- cos(factor    ) * BLACKMANHARRIS_A1
		+ cos(factor * 2) * BLACKMANHARRIS_A2 
		- cos(factor * 3) * BLACKMANHARRIS_A3;
		*/

	const Precision a[] = {
		(Precision)BLACKMANHARRIS_A0,
		(Precision)BLACKMANHARRIS_A1,
		(Precision)BLACKMANHARRIS_A2,
		(Precision)BLACKMANHARRIS_A3};

	return raised_cosine(w, a);
}
// ----------------------------------------

int main()
{
	std::cout << window_blackmanharris<float>( 3.f, 10.f) << std::endl;
	std::cin.get();

}

Willkommen im C++-Forum.

Dass sich Funktionstemplates nicht spezialisieren lassen, hast Du ja schon bemerkt. Nun - dann benutze keine Funktionen, sondern Strukturen und diese darfst Du partiell spezialisieren, wobei das hier gar nicht notwendig ist. Und weil eine Funktion benötigt wird, baue man sich eine statische Methode bei eben vorher erwähnter Struktur.

#include <cmath> // std::cos, u.a.
#include <iostream>

namespace
{
    const double PI = std::acos(-1.0);

    namespace blackman_harris
    {
        // siehe <http://de.wikipedia.org/wiki/Fensterfunktion#Blackman-Harris_Fenster>
        const double a[] = { 0.35875, 0.48829, 0.14128, 0.01168 };
    }
}

template< int N >
struct raised_cosine;

template< int N >
struct raised_cosine< N >
{
    static double calc( double n )
    {
        static_assert( N < sizeof(blackman_harris::a)/sizeof(*blackman_harris::a), "blackman_harris::a[N] fuer dieses N nicht verfuegbar" );
        static_assert( N > 1, "raised_cosine< N > erst ab N>1 definiert" );
        return calc_( 2*PI*n/(N-1) );
    }

    static double calc_( double w )
    {
        return raised_cosine< N-1 >::calc_( w ) + sgn( blackman_harris::a[N] ) * std::cos( w*N );
    }
    static double sgn( double a )
    {
        return -raised_cosine< N-1 >::sgn( a );
    }
};

template<>
struct raised_cosine< 0 >
{
    static double calc_( double /*w*/ )
    {
        return blackman_harris::a[0];
    }
    static double sgn( double a )
    {
        return a;
    }
};

int main()
{
    using namespace std;
    for( double x; cin >> x; )
        cout << "raised_cosine(" << x << ") = " << raised_cosine< 3 >::calc( x ) << endl;
    return 0;
}

Wenn man sich das ganze im Maschinencode anschaut, dann wird alles als ein Ausdruck ohne Schleife und ohne Unterprogramm-Aufruf übersetzt. Schneller ist es kaum zu machen. Zumal dort auch keine Multiplikation mit 1 oder -1 mehr passiert, so wie in Deinem Code.

Auf die defines in Deinem Code würde ich verzichten. Ein sprechender namespace ist hier die erste Wahl (s.Code).

Gruß
Werner

coole Lösung, die auf jeden Fall schöner ist. Namespaces sind schön, das stimmt, aber in deiner Lösung hat man nicht die Möglichkeit anderen a-Parameter zu verwenden, weil man namespaces nicht als Parameter übergeben kann. Es gibt ja noch mehrere raised_cosine Fenster, die ich einbauen will.

Ich könnte mir vorstellen noch einen "typename Coefs" als Parameter zu übergeben und auf die Koeffizienten über Coefs::a zugreifen, würde das gehen? Ich probier das morgen einmal aus.

Danke nochmal.

... in deiner Lösung hat man nicht die Möglichkeit anderen a-Parameter zu verwenden, weil man namespaces nicht als Parameter übergeben kann. Es gibt ja noch mehrere raised_cosine Fenster, die ich einbauen will.

Ich hatte nicht registriert, dass dies eine Anforderung ist. Aber das lässt sich doch leicht nachrüsten. Wenn Du da noch Fragen hast, so melde Dich einfach nochmal.

Gruß
Werner