void cacheTesting(){
Cache* cache = createCache(10, 4);
int cacheLineNum;
bool compute;
cacheCall(cache, 9, &cacheLineNum, &compute);
cacheCall(cache, 0, &cacheLineNum, &compute);
cacheCall(cache, 2, &cacheLineNum, &compute);
cacheCall(cache, 2, &cacheLineNum, &compute);
cacheCall(cache, 1, &cacheLineNum, &compute);
cacheCall(cache, 9, &cacheLineNum, &compute);
cacheCall(cache, 3, &cacheLineNum, &compute);
printf("%d%d\n",cacheLineNum,compute);
}
/*!
Dials a \a number if there are no currently active calls. If a
\a contact is specified, it is used as the contact to display and
insert into the call history. Before calling this function,
you should check that there are no incoming calls, or active calls.
If \a sendcallerid is true, then send the caller's identifier as part
of the dial sequence.
If \a callType is "Voice" a GSM call will be dialed. If \a callType is
"VoIP" a VoIP call will be dialed.
*/
void DialerControl::dial( const QString &number, bool sendcallerid, const QString& callType, const QUniqueId &contact )
{
QUniqueId matchedContact;
if (contact.isNull() && !number.isEmpty())
matchedContact = ServerContactModel::instance()->matchPhoneNumber(number).uid();
else
matchedContact = contact;
if ( isDialing() ) {
//qWarning("BUG! Attempt to dial while there is already a dialing call");
}
if( !hasActiveCalls() && !isDialing() )
{
// Collect up the dial options.
QDialOptions dialopts;
dialopts.setNumber( number );
if ( sendcallerid )
dialopts.setCallerId( QDialOptions::SendCallerId );
else
dialopts.setCallerId( QDialOptions::DefaultCallerId );
dialopts.setContact( matchedContact );
// Allow other parts of the server (e.g. GsmKeyActions) to
// modify the dial options to account for supplementary services.
bool handledAlready = false;
emit modifyDial( dialopts, handledAlready );
if ( handledAlready )
return;
// Call the specified number.
QPhoneCall call = createCall(callType);
phoneValueSpace.setAttribute( "LastDialedCall", QVariant(number) );
call.dial( dialopts );
// cache call here to preserve the information even if the battery run out.
cacheCall( call );
}
}
/*!
\internal
Constructs a DialerControl object and attaches it to \a parent.
*/
DialerControl::DialerControl( )
: QObject( 0 ), mCallList(50), mCallManager(0), aaTid(0),
mProfiles(0), missedCalls(0), phoneValueSpace("/Communications/Calls"),
activeCallCount(-1)
{
mCallManager = new QPhoneCallManager( this );
connect( mCallManager, SIGNAL(newCall(QPhoneCall)),
this, SLOT(newCall(QPhoneCall)) );
connect( this, SIGNAL(callIncoming(QPhoneCall)),
this, SLOT(cacheCall(QPhoneCall)) );
connect( this, SIGNAL(callDropped(QPhoneCall)),
this, SLOT(recordCall(QPhoneCall)) );
mProfiles = new QPhoneProfileManager(this);
QSettings setting("Trolltech", "qpe");
setting.beginGroup("CallControl");
missedCalls = setting.value("MissedCalls", 0).toInt();
phoneValueSpace.setAttribute("MissedCalls", QVariant(missedCalls));
doActiveCalls();
QTimer::singleShot( 0, this, SLOT(readCachedCall()) );
}
int train(int cacheSizeInFloats, float *input_data, int *labels,
float epsilon, float Ce, float cost, float tolerance,
int heuristic, int nPoints, int dFeatures,
float paramA, float paramB, float paramC,
size_t localInitSize, size_t globalInitSize,
int numGroups_foph1, size_t localFoph1Size, size_t globalFoph1Size,
size_t localFoph2Size, size_t globalFoph2Size,
int numGroups_soph1, size_t localSoph1Size, size_t globalSoph1Size,
size_t localSoph2Size, size_t globalSoph2Size,
int numGroups_soph3, size_t localSoph3Size, size_t globalSoph3Size,
size_t localSoph4Size, size_t globalSoph4Size,
cl_mem d_input_data, cl_mem d_input_data_colmajor, cl_mem d_labels, cl_mem d_trainingAlpha, cl_mem d_kernelDiag, cl_mem d_F,
cl_mem d_highFsFO, cl_mem d_highIndicesFO, cl_mem d_lowFsFO, cl_mem d_lowIndicesFO,
cl_mem d_highFsSO1, cl_mem d_highIndicesSO1, cl_mem d_lowFsSO3, cl_mem d_lowIndicesSO3, cl_mem d_deltaFsSO3,
cl_mem d_results, cl_mem d_cache,
cl_command_queue queue, cl_kernel init, cl_kernel step1, cl_kernel foph1, cl_kernel foph2,
cl_kernel soph1, cl_kernel soph2, cl_kernel soph3, cl_kernel soph4,
float *p_rho, int *p_nSV, int *p_iterations,
float **p_signedAlpha, float **p_supportVectors){
int numCacheLines = cacheSizeInFloats/nPoints;
Cache *cache = createCache(nPoints,numCacheLines);
Controller *progress = createController(2.0, 64 ,nPoints);
int err;
err = 0;
err |= clSetKernelArg(init, 0, sizeof(cl_mem), &d_input_data);
err |= clSetKernelArg(init, 1, sizeof(cl_mem), &d_labels);
err |= clSetKernelArg(init, 2, sizeof(cl_mem), &d_F);
err |= clSetKernelArg(init, 3, sizeof(cl_mem), &d_kernelDiag);
err |= clSetKernelArg(init, 4, sizeof(int), &nPoints);
err |= clSetKernelArg(init, 5, sizeof(int), &dFeatures);
err |= clSetKernelArg(init, 6, sizeof(float), ¶mA);
err |= clSetKernelArg(init, 7, sizeof(float), ¶mB);
err |= clSetKernelArg(init, 8, sizeof(float), ¶mC);
if (err != CL_SUCCESS){
printf("Error: Failed to set kernel arguments! %d\n", err);
return err;
}
err = clEnqueueNDRangeKernel(queue, init, 1, NULL, &globalInitSize, &localInitSize, 0, NULL, NULL);
if (err != CL_SUCCESS){
printf("Error: Failed to execute kernel init!\n");
printf("Global Size:%zu, Local Size:%zu\n", globalInitSize, localInitSize);
return err;
}
float bLow;
float bHigh;
int iLow;
int iHigh;
float alpha1diff;
float alpha2diff;
size_t globalStep1Size = 1;
size_t localStep1Size = 1;
err = 0;
err |= clSetKernelArg(step1, 0, sizeof(cl_mem), &d_input_data);
err |= clSetKernelArg(step1, 1, sizeof(cl_mem), &d_labels);
err |= clSetKernelArg(step1, 2, sizeof(cl_mem), &d_trainingAlpha);
err |= clSetKernelArg(step1, 3, sizeof(cl_mem), &d_kernelDiag);
err |= clSetKernelArg(step1, 4, sizeof(float), &cost);
err |= clSetKernelArg(step1, 5, sizeof(int), &nPoints);
err |= clSetKernelArg(step1, 6, sizeof(int), &dFeatures);
err |= clSetKernelArg(step1, 7, sizeof(float), ¶mA);
err |= clSetKernelArg(step1, 8, sizeof(float), ¶mB);
err |= clSetKernelArg(step1, 9, sizeof(float), ¶mC);
err |= clSetKernelArg(step1, 10, sizeof(cl_mem), &d_results);
if (err != CL_SUCCESS){
printf("Error: Failed to set kernel arguments! %d\n", err);
return err;
}
err = clEnqueueNDRangeKernel(queue, step1, 1, NULL, &globalStep1Size, &localStep1Size, 0, NULL, NULL);
if (err != CL_SUCCESS){
printf("Error: Failed to execute kernel step1!\n");
return err;
}
err = clFinish(queue);
if (err != CL_SUCCESS){
printf("Error: waiting for queue to finish failed\n");
return err;
}
float results[8];
getResults(queue, d_results, results, &bLow, &bHigh, &iLow, &iHigh, &alpha1diff, &alpha2diff);
int iteration;
bool iLowCompute;
bool iHighCompute;
int iLowCacheIndex;
int iHighCacheIndex;
int currentHeuristic;
// clock_t startTot = clock(), diffTot, diffSoph1, diffSoph2, diffSoph3, diffSoph4, diffGetResults;
for (iteration = 0; true; iteration++){
if(heuristic == 2){
currentHeuristic = progress->heuristic;
}else{
currentHeuristic = heuristic;
}
if(bLow <= bHigh + 2 * tolerance){
break;
}
if ((iteration & 0x7ff) == 0) {
printf("iteration: %d; gap: %f\n",iteration, bLow - bHigh);
}
cacheCall(cache,iHigh, &iHighCacheIndex, &iHighCompute);
cacheCall(cache,iLow, &iLowCacheIndex, &iLowCompute);
alpha1diff = labels[iHigh] * alpha1diff;
alpha2diff = labels[iLow] * alpha2diff;
if (currentHeuristic == 0){
// Set the arguments to foph1
//
err = 0;
err = clSetKernelArg(foph1, 0, sizeof(cl_mem), &d_input_data);
err |= clSetKernelArg(foph1, 1, sizeof(cl_mem), &d_labels);
err |= clSetKernelArg(foph1, 2, sizeof(cl_mem), &d_trainingAlpha);
err |= clSetKernelArg(foph1, 3, sizeof(cl_mem), &d_F);
err |= clSetKernelArg(foph1, 4, sizeof(cl_mem), &d_lowFsFO);
err |= clSetKernelArg(foph1, 5, sizeof(cl_mem), &d_highFsFO);
err |= clSetKernelArg(foph1, 6, sizeof(cl_mem), &d_lowIndicesFO);
err |= clSetKernelArg(foph1, 7, sizeof(cl_mem), &d_highIndicesFO);
err |= clSetKernelArg(foph1, 8, sizeof(int), &nPoints);
err |= clSetKernelArg(foph1, 9, sizeof(int), &dFeatures);
err |= clSetKernelArg(foph1, 10, sizeof(float), &epsilon);
err |= clSetKernelArg(foph1, 11, sizeof(float), &Ce);
err |= clSetKernelArg(foph1, 12, sizeof(int), &iHigh);
err |= clSetKernelArg(foph1, 13, sizeof(int), &iLow);
err |= clSetKernelArg(foph1, 14, sizeof(float), &alpha1diff);
err |= clSetKernelArg(foph1, 15, sizeof(float), &alpha2diff);
err |= clSetKernelArg(foph1, 16, sizeof(float), ¶mA);
err |= clSetKernelArg(foph1, 17, sizeof(float), ¶mB);
err |= clSetKernelArg(foph1, 18, sizeof(float), ¶mC);
err |= clSetKernelArg(foph1, 19, sizeof(int) * localFoph1Size, NULL);
err |= clSetKernelArg(foph1, 20, sizeof(float) * localFoph1Size, NULL);
err |= clSetKernelArg(foph1, 21, sizeof(cl_mem), &d_cache);
err |= clSetKernelArg(foph1, 22, sizeof(bool), &iHighCompute);
err |= clSetKernelArg(foph1, 23, sizeof(bool), &iLowCompute);
err |= clSetKernelArg(foph1, 24, sizeof(int), &iHighCacheIndex);
err |= clSetKernelArg(foph1, 25, sizeof(int),&iLowCacheIndex);
if (err != CL_SUCCESS){
printf("Error: Failed to set kernel arguments! %d\n", err);
return err;
}
err = clEnqueueNDRangeKernel(queue, foph1, 1, NULL, &globalFoph1Size, &localFoph1Size, 0, NULL, NULL);
if (err != CL_SUCCESS){
printf("Error: Failed to execute kernel Foph1!\n");
return err;
}
// Set the arguments to foph2
//
err = 0;
err = clSetKernelArg(foph2, 0, sizeof(cl_mem), &d_input_data);
err |= clSetKernelArg(foph2, 1, sizeof(cl_mem), &d_labels);
err |= clSetKernelArg(foph2, 2, sizeof(cl_mem), &d_trainingAlpha);
err |= clSetKernelArg(foph2, 3, sizeof(cl_mem), &d_kernelDiag);
err |= clSetKernelArg(foph2, 4, sizeof(cl_mem), &d_lowFsFO);
err |= clSetKernelArg(foph2, 5, sizeof(cl_mem), &d_highFsFO);
err |= clSetKernelArg(foph2, 6, sizeof(cl_mem), &d_lowIndicesFO);
err |= clSetKernelArg(foph2, 7, sizeof(cl_mem), &d_highIndicesFO);
err |= clSetKernelArg(foph2, 8, sizeof(cl_mem), &d_results);
err |= clSetKernelArg(foph2, 9, sizeof(float), &cost);
err |= clSetKernelArg(foph2, 10, sizeof(int), &dFeatures);
err |= clSetKernelArg(foph2, 11, sizeof(int), &numGroups_foph1);
err |= clSetKernelArg(foph2, 12, sizeof(float), ¶mA);
err |= clSetKernelArg(foph2, 13, sizeof(float), ¶mB);
err |= clSetKernelArg(foph2, 14, sizeof(float), ¶mC);
err |= clSetKernelArg(foph2, 15, sizeof(int) * localFoph2Size, NULL);
err |= clSetKernelArg(foph2, 16, sizeof(float) * localFoph2Size, NULL);
if (err != CL_SUCCESS){
printf("Error: Failed to set kernel arguments! %d\n", err);
return err;
}
err = clEnqueueNDRangeKernel(queue, foph2, 1, NULL, &globalFoph2Size, &localFoph2Size, 0, NULL, NULL);
if (err != CL_SUCCESS){
printf("Error: Failed to execute kernel Foph2!\n");
return err;
}
// Wait for the command queue to get serviced before reading back results
//
err = clFinish(queue);
if (err != CL_SUCCESS){
printf("Error: waiting for queue to finish failed\n");
return err;
}
getResults(queue, d_results, results, &bLow, &bHigh, &iLow, &iHigh, &alpha1diff, &alpha2diff);
}else{
// Set the arguments to soph1
//
// clock_t startSoph1 = clock();
err = 0;
err = clSetKernelArg(soph1, 0, sizeof(cl_mem), &d_input_data);
err |= clSetKernelArg(soph1, 1, sizeof(cl_mem), &d_labels);
err |= clSetKernelArg(soph1, 2, sizeof(cl_mem), &d_trainingAlpha);
err |= clSetKernelArg(soph1, 3, sizeof(cl_mem), &d_F);
err |= clSetKernelArg(soph1, 4, sizeof(cl_mem), &d_highFsSO1);
err |= clSetKernelArg(soph1, 5, sizeof(cl_mem), &d_highIndicesSO1);
err |= clSetKernelArg(soph1, 6, sizeof(int), &nPoints);
err |= clSetKernelArg(soph1, 7, sizeof(int), &dFeatures);
err |= clSetKernelArg(soph1, 8, sizeof(float), &epsilon);
err |= clSetKernelArg(soph1, 9, sizeof(float), &Ce);
err |= clSetKernelArg(soph1, 10, sizeof(int), &iHigh);
err |= clSetKernelArg(soph1, 11, sizeof(int), &iLow);
err |= clSetKernelArg(soph1, 12, sizeof(float), &alpha1diff);
err |= clSetKernelArg(soph1, 13, sizeof(float), &alpha2diff);
err |= clSetKernelArg(soph1, 14, sizeof(float), ¶mA);
err |= clSetKernelArg(soph1, 15, sizeof(float), ¶mB);
err |= clSetKernelArg(soph1, 16, sizeof(float), ¶mC);
err |= clSetKernelArg(soph1, 17, sizeof(int) * localSoph1Size, NULL);
err |= clSetKernelArg(soph1, 18, sizeof(float) * localSoph1Size, NULL);
err |= clSetKernelArg(soph1, 19, sizeof(cl_mem), &d_cache);
err |= clSetKernelArg(soph1, 20, sizeof(bool), &iHighCompute);
err |= clSetKernelArg(soph1, 21, sizeof(bool), &iLowCompute);
err |= clSetKernelArg(soph1, 22, sizeof(int), &iHighCacheIndex);
err |= clSetKernelArg(soph1, 23, sizeof(int),&iLowCacheIndex);
if (err != CL_SUCCESS){
printf("Error: Failed to set kernel arguments! %d\n", err);
return err;
}
err = clEnqueueNDRangeKernel(queue, soph1, 1, NULL, &globalSoph1Size, &localSoph1Size, 0, NULL, NULL);
if (err != CL_SUCCESS){
printf("Error: Failed to execute kernel Soph1!\n");
return err;
}
// clFinish(queue);
// diffSoph1 = clock() - startSoph1;
// clock_t startSoph2 = clock();
// Set the arguments to soph2
//
err = 0;
err |= clSetKernelArg(soph2, 0, sizeof(cl_mem), &d_highFsSO1);
err |= clSetKernelArg(soph2, 1, sizeof(cl_mem), &d_highIndicesSO1);
err |= clSetKernelArg(soph2, 2, sizeof(cl_mem), &d_results);
err |= clSetKernelArg(soph2, 3, sizeof(int), &numGroups_soph1);
err |= clSetKernelArg(soph2, 4, sizeof(int) * localSoph2Size, NULL);
err |= clSetKernelArg(soph2, 5, sizeof(float) * localSoph2Size, NULL);
if (err != CL_SUCCESS){
printf("Error: Failed to set kernel arguments! %d\n", err);
return err;
}
err = clEnqueueNDRangeKernel(queue, soph2, 1, NULL, &globalSoph2Size, &localSoph2Size, 0, NULL, NULL);
if (err != CL_SUCCESS){
printf("Error: Failed to execute kernel Soph2!\n");
return err;
}
// clFinish(queue);
// diffSoph2 = clock() - startSoph2;
// Set the arguments to soph3
//
clFinish(queue);
getResults(queue, d_results, results, &bLow, &bHigh, &iLow, &iHigh, &alpha1diff, &alpha2diff);
// clock_t startSoph3 = clock();
cacheCall(cache, iHigh, &iHighCacheIndex, &iHighCompute);
err = 0;
err = clSetKernelArg(soph3, 0, sizeof(cl_mem), &d_input_data);
err |= clSetKernelArg(soph3, 1, sizeof(cl_mem), &d_labels);
err |= clSetKernelArg(soph3, 2, sizeof(cl_mem), &d_trainingAlpha);
err |= clSetKernelArg(soph3, 3, sizeof(cl_mem), &d_F);
err |= clSetKernelArg(soph3, 4, sizeof(cl_mem), &d_kernelDiag);
err |= clSetKernelArg(soph3, 5, sizeof(cl_mem), &d_lowFsSO3);
err |= clSetKernelArg(soph3, 6, sizeof(cl_mem), &d_lowIndicesSO3);
err |= clSetKernelArg(soph3, 7, sizeof(cl_mem), &d_deltaFsSO3);
err |= clSetKernelArg(soph3, 8, sizeof(cl_mem), &d_results);
err |= clSetKernelArg(soph3, 9, sizeof(int), &iHigh);
err |= clSetKernelArg(soph3, 10, sizeof(float), &bHigh);
err |= clSetKernelArg(soph3, 11, sizeof(int), &nPoints);
err |= clSetKernelArg(soph3, 12, sizeof(int), &dFeatures);
err |= clSetKernelArg(soph3, 13, sizeof(float), &epsilon);
err |= clSetKernelArg(soph3, 14, sizeof(float), &Ce);
err |= clSetKernelArg(soph3, 15, sizeof(float), ¶mA);
err |= clSetKernelArg(soph3, 16, sizeof(float), ¶mB);
err |= clSetKernelArg(soph3, 17, sizeof(float), ¶mC);
err |= clSetKernelArg(soph3, 18, sizeof(int) * localSoph3Size, NULL);
err |= clSetKernelArg(soph3, 19, sizeof(float) * localSoph3Size, NULL);
err |= clSetKernelArg(soph3, 20, sizeof(cl_mem), &d_cache);
err |= clSetKernelArg(soph3, 21, sizeof(bool), &iHighCompute);
err |= clSetKernelArg(soph3, 22, sizeof(int), &iHighCacheIndex);
if (err != CL_SUCCESS){
printf("Error: Failed to set kernel arguments! %d\n", err);
return err;
}
err = clEnqueueNDRangeKernel(queue, soph3, 1, NULL, &globalSoph3Size, &localSoph3Size, 0, NULL, NULL);
if (err != CL_SUCCESS){
printf("Error: Failed to execute kernel Soph3!\n");
return err;
}
// clFinish(queue);
// diffSoph3 = clock() - startSoph3;
// Set the arguments to soph4
//
// clock_t startSoph4 = clock();
err = 0;
err = clSetKernelArg(soph4, 0, sizeof(cl_mem), &d_input_data);
err |= clSetKernelArg(soph4, 1, sizeof(cl_mem), &d_labels);
err |= clSetKernelArg(soph4, 2, sizeof(cl_mem), &d_trainingAlpha);
err |= clSetKernelArg(soph4, 3, sizeof(cl_mem), &d_kernelDiag);
err |= clSetKernelArg(soph4, 4, sizeof(cl_mem), &d_lowFsSO3);
err |= clSetKernelArg(soph4, 5, sizeof(cl_mem), &d_lowIndicesSO3);
err |= clSetKernelArg(soph4, 6, sizeof(cl_mem), &d_deltaFsSO3);
err |= clSetKernelArg(soph4, 7, sizeof(cl_mem), &d_results);
err |= clSetKernelArg(soph4, 8, sizeof(float), &cost);
err |= clSetKernelArg(soph4, 9, sizeof(int), &dFeatures);
err |= clSetKernelArg(soph4, 10, sizeof(int), &numGroups_soph3);
err |= clSetKernelArg(soph4, 11, sizeof(float), ¶mA);
err |= clSetKernelArg(soph4, 12, sizeof(float), ¶mB);
err |= clSetKernelArg(soph4, 13, sizeof(float), ¶mC);
err |= clSetKernelArg(soph4, 14, sizeof(cl_mem), &d_F);
err |= clSetKernelArg(soph4, 15, sizeof(int) * localSoph4Size, NULL);
err |= clSetKernelArg(soph4, 16, sizeof(float) * localSoph4Size, NULL);
if (err != CL_SUCCESS){
printf("Error: Failed to set kernel arguments! %d\n", err);
return err;
}
err = clEnqueueNDRangeKernel(queue, soph4, 1, NULL, &globalSoph4Size, &localSoph4Size, 0, NULL, NULL);
if (err != CL_SUCCESS){
printf("Error: Failed to execute kernel Soph4!\n");
return err;
}
// clFinish(queue);
// diffSoph4 = clock() - startSoph4;
// Wait for the command queue to get serviced before reading back results
//
err = clFinish(queue);
if (err != CL_SUCCESS){
printf("Error: waiting for queue to finish failed\n");
return err;
}
// clock_t startGetResults = clock();
getResults(queue, d_results, results, &bLow, &bHigh, &iLow, &iHigh, &alpha1diff, &alpha2diff);
// clFinish(queue);
// diffGetResults = clock() - startGetResults;
//printf("iLow:%d, iHigh:%d\n", (int)results[2], (int)results[3]);
}
if(heuristic == 2){
addIteration(progress, bLow - bHigh);
}
}
printf("INFO: %d iterations\n", iteration);
printf("INFO: bLow: %f, bHigh %f\n", bLow, bHigh);
// diffTot = clock() - startTot;
// float msecTot = diffTot * 1000.0 / CLOCKS_PER_SEC;
// printf("Total time taken %.5f milliseconds\n", msecTot);
// float msecSoph1 = diffSoph1 * 1000.0 / CLOCKS_PER_SEC;
// printf("Soph1 time taken %.5f milliseconds\n", msecSoph1);
// float msecSoph2 = diffSoph2 * 1000.0 / CLOCKS_PER_SEC;
// printf("Soph2 time taken %.5f milliseconds\n", msecSoph2);
// float msecSoph3 = diffSoph3 * 1000.0 / CLOCKS_PER_SEC;
// printf("Soph3 time taken %.5f milliseconds\n", msecSoph3);
// float msecSoph4 = diffSoph4 * 1000.0 / CLOCKS_PER_SEC;
// printf("Soph4 time taken %.5f milliseconds\n", msecSoph4);
// float msecGetResults = diffGetResults * 1000.0 / CLOCKS_PER_SEC;
// printf("GetResult time taken %.5f milliseconds\n", msecGetResults);
// get training alpha
float *trainingAlpha = (float *)malloc(sizeof(float) * nPoints);
err = clEnqueueReadBuffer(queue, d_trainingAlpha, CL_TRUE, 0, sizeof(float) * nPoints, trainingAlpha, 0, NULL, NULL);
if (err != CL_SUCCESS){
printf("Error: Failed to read buffer\n");
return err;
}
// save results
*p_rho = (bHigh + bLow)/2;
int nSV = 0;
for(int i = 0; i < nPoints; i++){
if (trainingAlpha[i] > epsilon){
nSV++;
}
}
int index = 0;
*p_nSV = nSV;
*p_supportVectors = (float *)malloc(sizeof(float) * nSV * dFeatures);
*p_signedAlpha = (float *)malloc(sizeof(float) * nSV);
for(int i = 0; i < nPoints; i++){
if(trainingAlpha[i] > epsilon){
(* p_signedAlpha)[index] = labels[i] * trainingAlpha[i];
for(int j = 0; j < dFeatures; j++){
(* p_supportVectors)[index*dFeatures + j] = input_data[i * dFeatures + j];
}
index ++;
}
}
// Shutdown and cleanup
//
printf("%d Cache Hits!\n",cache->hits);
printf("%d Cache Misses!\n",cache->misses);
return 0;
}
