Yeah maybe float is just fine for most of the variables in that struct. I didn't think that through yet. I just ran into above practical issue, so I suggest to have another look.

double and float are not the same thing. double is 8 bytes and float is 4 bytes. double can present significantly more numbers than float. If there comes a precision loss depends on the intended use.

The only solid reason to use float over double here (afaik) is to decrease the amount of memory needed for 1 TRADE instance, effectively halving it. Depending on your strategy code you will have different amount of trades. So decreasing its memory footprint is generally appreciated, especially if the application keeps all opened and closed trades in memory.

Conversion to float will definitely break all code where you want to use the 8 bytes of a double as pure storage. A more elegant solution for this case would be to add a void* member to the TRADE struct reserved for user data. Since a TRADE struct does not seem to provide a unique ID, you also cannot accompany it with a map of trade user data.

What are these variables for? Are these free for the user? Maybe the comment is just misleading.
Code:
var	Skill[NUM_SKILLS];	// general purpose variables for TMF


For prices, please correct me if my test is wrong, we could check if the storage precision is a problem like so.
I assume a 5 digit price precision for this test.

Code:
void main()
{	
	float f1 = 0.0;
	float f2 = 0.0;
	double d1 = 0.0;
	double d2 = 0.0;
	int i;
	
	printf("nBusy...");
	
	for (i=0; i<0x7fffffff; ++i)
	{
		d1 += 0.00001;
		f1 = d1;
		d2 = f1;
		if (d1 != d2)
		{
			printf("nMismatch %.5f vs %.5f", d1, d2);
			break;
		}
	}
	
	printf("nDone.");
}


Result:

Quote:
Busy...
Mismatch 0.00007 vs 0.00007
Done.


Ok. There is a mismatch quite early but that has to be expected. It will be a very insignificant small digit.
So lets round the double after we took it from float into our desired precision.

Code:
void main()
{	
	double pip = 0.00001;
	float f1 = 0.0;
	float f2 = 0.0;
	double d1 = 0.0;
	double d2 = 0.0;
	int i;
	
	printf("nBusy...");
	
	for (i=0; i<0x7fffffff; ++i)
	{
		d1 += pip;
		f1 = d1;
		d2 = f1;
		if (round(d1,pip) != round(d2,pip))
		{
			printf("nMismatch %.5f vs %.5f", d1, d2);
			break;
		}
	}
	
	printf("nDone.");
}


Quote:
Busy...
Mismatch 128.00001 vs 128.00000
Done.


So the first mismatch with 0.00001 precision occurs at a relatively high value. Is that good enough? I think so yes.