Jag tror talet är ett mått på ett värde som ska vara förhållandet tiden och klockcyklerna, ja.
Tittar man på ekvationen så är det tydligt (end - start)) / CLOCKS_PER_SEC.
Formeln är T2-T1, där T2 och T2 är CPU tid.
Detta delas med CLOCKS_PER_SEC som är ett mått på hur många klockcykler per sekund.
Hur som helst så är jag klar med min algoritm.
Denna hittar alltså lösningen till Ax=b systemet.
Kod: Markera allt
>> A = [5 10; -4 5]
A =
5 10
-4 5
>> b = [53 + 8; 3 + 7]
b =
61
10
>> x = linsolve(A, b)
x =
3.1538
4.5231
>>
Min lösning med denna C-kod blev.
När jag körde detta ekvationssystem. Vektorn b kan betraktas som konstant.
Kod: Markera allt
void func(float* dx, float* b, float* x){
dx[0] = 53*b[0] + 8*b[1] - (5*x[0] + 10*x[1]);
dx[1] = 3*b[0] + 7*b[1] - (-4*x[0] + 5*x[1]);
}
I nedre fallet så använder jag mig utav ett mycket olinjärt ekvationssystem.
Kod: Markera allt
#include <stdio.h>
#include <stdlib.h>
#include <time.h>
#include <stdint.h>
#include <math.h>
void increment(uint8_t* index, float* x, uint8_t* elements, float* step, float* max_value, float* min_value){
if(*index >= *elements - 1)
return;
*index = *index + 1;
x[*index] += *step;
if(x[*index] > *max_value){
x[*index] = *min_value;
increment(index, x, elements, step, max_value, min_value);
}
*index = *index - 1;
}
void check_solution(float* dx, float* x, float* past_sum_dx, float* best_x, uint8_t* elements){
// Do L2-norm on dx
float sum = 0;
for(uint8_t i = 0; i < *elements; i++){
sum += dx[i]*dx[i];
}
sum = sqrtf(sum);
// Check the condition
if(*past_sum_dx > sum){
*past_sum_dx = sum;
memcpy(best_x, x, sizeof(float)* *elements);
}
}
void nonlinsolve(void (*nonlinear_equation_system)(float*, float*, float*), float* b, float* x, uint8_t elements, float step, float max_value, float min_value){
// Initial parameters and arrays
uint8_t index = 0;
float dx[elements];
float past_sum_dx = FLT_MAX;
float best_x[elements];
// Do the process
for(uint32_t i = 0; i < powf(max_value - min_value + 1, elements); i++){
for(float j = min_value; j <= max_value; j += step){
x[index] = j;
(*nonlinear_equation_system)(dx, b, x);
check_solution(dx, x, &past_sum_dx, best_x, &elements);
}
increment(&index, x, &elements, &step, &max_value, &min_value);
}
// Copy over our final solution x
memcpy(x, best_x, sizeof(float)*elements);
}
void print(float* A, int row, int column) {
for (int i = 0; i < row; i++) {
for (int j = 0; j < column; j++) {
printf("%0.18f\t", *(A++));
}
printf("\n");
}
printf("\n");
}
void func(float* dx, float* b, float* x){
dx[0] = 53*b[0] + 8*b[1] - (5*x[0]*x[0] + 10*x[1]*x[1]*x[1]);
dx[1] = 3*b[0] + 7*b[1] - (-4*x[0] + 5*x[1]*x[0]);
}
int main() {
// Initial parameters
float x[2] = {0,0};
float b[2] = {1, 1};
uint8_t elements = 2;
float min_value = -50;
float max_value = 70;
float step = 0.001;
// Start clock
clock_t start, end;
float cpu_time_used;
start = clock();
// Do the process
nonlinsolve(func, b, x, elements, step, max_value, min_value);
printf("Solution:\n");
print(x, 1, elements);
printf("Accuracy:\n");
float dx[elements];
func(dx, b, x);
print(dx, 1, elements);
// Compute the speed
end = clock();
cpu_time_used = ((float) (end - start)) / CLOCKS_PER_SEC;
printf("\nTotal speed was %f\n", cpu_time_used);
return EXIT_SUCCESS;
}