#include "stdafx.h"
#include "math.h"
#include <iostream>
#include "hasp_api.h"
#include "hasp_vcode.h"
typedef float (*func6)(float x1, float x2, float x3, float x4, float x5, float x6);
float res[6];
float rounding(float value, int sign)
{
float x = value * (pow(10.0, sign));
float y=floor(x) / (pow(10.0, sign));
return y;
}
float evaluating_the_function_of_six_variables(func6 func, func6 del)
{
const int count_of_variables = 6;
const int count_of_combinations = (int)pow(double(2), count_of_variables);
int sign = 4;
float error = 1.0 / (pow(10, sign));
float ranges[count_of_variables][2] = {
{ -1, 1 },
{ -1, 1 },
{ -1, 1 },
{ -1, 1 },
{ -1, 1 },
{ -1, 1 }
};
float max_res, best_variant[count_of_variables], variants_of_variable[count_of_variables][2];
bool result_found = false, max_res_flag = false;
while(result_found == false)
{
for (int i=0; i < count_of_variables; ++i)
{
float range_size = ranges[i][1] - ranges[i][0];
float range_center = (ranges[i][1] + ranges[i][0])/ 2;
range_center = rounding(range_center, sign);
if (range_size > error)
{
variants_of_variable[i][0] = range_center - error;
variants_of_variable[i][1] = range_center + error;
}
else
{
variants_of_variable[i][0] = range_center;
variants_of_variable[i][1] = range_center;
}
}
float max_res_step;
bool max_res_step_initialized = false;
float best_var_step[count_of_variables];
float prew_best_var[count_of_variables];
for (int i=0; i < count_of_combinations; ++i)
{
float variant[count_of_variables];
for (int j=0; j < count_of_variables; ++j)
{
variant[j] = variants_of_variable[j][(i / ((int)(count_of_combinations / (int)pow(float(2), j+1)))) % 2];
}
if (del(variant[0], variant[1], variant[2], variant[3], variant[4], variant[5]) != 0)
{
float result = func(variant[0], variant[1], variant[2], variant[3], variant[4], variant[5]);
if (max_res_step_initialized == false)
{
max_res_step_initialized = true;
max_res_step = result;
memcpy(best_var_step, variant, sizeof(variant));
}
else
{
if (result < max_res_step)
{
max_res_step = result;
memcpy(best_var_step, variant, sizeof(variant));
}
}
}
}
if (max_res_flag == false)
{
max_res_flag = true;
max_res = max_res_step;
memcpy(best_variant, best_var_step, sizeof(best_variant));
}
else
{
if (memcmp(prew_best_var, best_var_step, sizeof(best_variant)) == 0)
{
result_found = true;
break;
}
else
{
memcpy(prew_best_var, best_var_step, sizeof(best_variant));
if (max_res_step < max_res)
{
max_res = max_res_step;
memcpy(best_variant, best_var_step, sizeof(best_variant));
}
}
}
for (int i=0; i < count_of_variables; ++i)
{
float range_size = ranges[i][1] - ranges[i][0];
float range_center = (ranges[i][1] + ranges[i][0]) / 2;
range_center = rounding(range_center, sign);
if (best_var_step[i] < range_center)
{
ranges[i][1] = range_center;
}
else
{
ranges[i][0] = range_center;
}
}
}
float max=rounding(max_res,sign);
printf("Result == %.3f\n", max);
printf("x1 = %.3f, x2 = %.3f, x3 = %.3f, x4 = %.3f, x5 = %.3f, x6 = %.3f\n",
best_variant[0], best_variant[1], best_variant[2], best_variant[3], best_variant[4], best_variant[5]);
for(int i=0; i < 6; ++i)
{
res[i] = best_variant[i];
}
res[6] = max;
return max;
}
float func_of_6_variables(float x1,float x2,float x3,float x4,float x5,float x6)
{
float y=5*x1+pow(x2,2)+3*x3-4*x4+x5-1+x6;
return y;
}
float delenie(float x1,float x2,float x3,float x4,float x5,float x6)
{
return 1;
}
void main()
{
hasp_handle_t handle = HASP_INVALID_HANDLE_VALUE;
hasp_status_t status;
const hasp_feature_t feature = HASP_DEFAULT_FID;
status = hasp_login(feature, vendor_code, &handle); //открываем сессию
if(status != HASP_STATUS_OK)
{
printf("ERROR! Unlicensed software usage!\n"); //выдаём ошибку в случае неудачи
exit(0); //и прекращаем работу приложения
}
hasp_encrypt(handle, &res, 64); //зашифровываем рабочий массив с помощью аппаратного ключа HASP
hasp_write(handle, HASP_FILEID_RW, 0, 64, res); //записываем в память ключа зашифрованный массив
status = hasp_logout(handle); //закрываем сессию
status = hasp_login(feature, vendor_code, &handle); //снова открываем сессию
if(status != HASP_STATUS_OK)
{
printf("ERROR! Unlicensed software usage!\n");
exit(0);
}
hasp_read(handle, HASP_FILEID_RO, 0, 64, &res); //считываем из памяти ключа зашифрованный массив
hasp_decrypt(handle, &res, 64); //дешифруем его для дальнейшего использования в приложении
status = hasp_logout(handle); //закрываем сессию
evaluating_the_function_of_six_variables(func_of_6_variables,delenie);
}