int main()
{
const int N = 16;
float a[N*N];
float b[N*N];
float c[N*N];
for (int i = 0; i < N; i++)
for (int j = 0; j < N; j++)
{
a[i+j*N] = 10 + i;
b[i+j*N] = (float)j / N;
}
int start_time=GetMicroseconds();
add_matrix(a, b, c, N);
int end_time=GetMicroseconds();
for (int i = 0; i < N; i++)
{
for (int j = 0; j < N; j++)
{
printf("%0.2f ", c[i+j*N]);
}
printf("\n");
}
printf("\n time elapsed is: %i \n",end_time-start_time);
}
int main()
{
const int N = 1024;
float *a = new float[N*N];
float *b = new float[N*N];
float *c = new float[N*N];
for (int i = 0; i < N; i++)
for (int j = 0; j < N; j++)
{
a[i+j*N] = 10 + i;
b[i+j*N] = (float)j / N;
}
ResetMilli();
add_matrix(a, b, c, N);
printf("Total time in ms: %d\n", GetMicroseconds());
/* for (int i = 0; i < N; i++) */
/* { */
/* for (int j = 0; j < N; j++) */
/* { */
/* printf("%0.2f ", c[i+j*N]); */
/* } */
/* printf("\n"); */
/* } */
}
int main()
{
matrix_t m1;
matrix_t m2;
matrix_t m3;
int choice;
char file_1[20];
char file_2[20];
int r1,c1,r2,c2;
printf("Enter the first file name\n");
scanf("%s", file_1);
printf("Enter its row size & coloumn size\n");
scanf("%d%d", &r1,&c1);
printf("Enter the second file name\n");
scanf("%s", file_2);
printf("Enter its row size & coloumn size\n");
scanf("%d%d",&r2, &c2);
m1=init(m1,r1,c1);
m2=init(m2,r2,c2);
//create the list of first matrix
m1=create_list(m1,file_1);
//Creating the list of second matrix
m2=create_list(m2,file_2);
printf("_____________________________________________________________________________________________________________________________________________\n");
printf("First matrix list\n");
printf("______________________________________________________________________________________________________________________________________________\n");
display(m1);
printf("_______________________________________________________________________________________________________________________________________________\n");
printf("Second matrix list\n");
printf("_______________________________________________________________________________________________________________________________________________\n");
display(m2);
printf("_______________________________________________________________________________________________________________________________________________\n");
printf("\t\t\t\t\t Operations menu\n");
printf("1.Add\n");
printf("2.Multiply\n");
scanf("%d", &choice);
switch(choice)
{
case 1:
m3=add_matrix(m1,m2,m3);
printf("___________________________________________________________________________________________________________________________\n");
printf("Sum list\n");
printf("_____________________________________________________________________________________________________________________________\n");
display(m3);
printf("______________________________________________________________________________________________________________________________\n");
break;
case 2:
m3=multiply_matrix(m1,m2,m3);
printf("____________________________________________________________________________________________________________________________\n");
printf("Product list \n");
printf("______________________________________________________________________________________________________________________________\n");
display(m3);
printf("____________________________________________________________________________________________________________________________\n");
break;
deafault:
exit(0);
}
return 0;
}
int main()
{
Crosslist mat1, mat2, mat3;
creat_matrix(&mat1);
print_matrix(&mat1);
creat_matrix(&mat2);
print_matrix(&mat2);
add_matrix(&mat1, &mat2, &mat3);
print_matrix(&mat3);
return 0;
}
void estimate(KalmanFilter f) {
/* Calculate innovation */
multiply_matrix(f.observation_model, f.predicted_state,
f.innovation);
subtract_matrix(f.observation, f.innovation,
f.innovation);
/* Calculate innovation covariance */
multiply_by_transpose_matrix(f.predicted_estimate_covariance,
f.observation_model,
f.vertical_scratch);
multiply_matrix(f.observation_model, f.vertical_scratch,
f.innovation_covariance);
add_matrix(f.innovation_covariance, f.observation_noise_covariance,
f.innovation_covariance);
/* Invert the innovation covariance.
Note: this destroys the innovation covariance.
TODO: handle inversion failure intelligently. */
destructive_invert_matrix(f.innovation_covariance,
f.inverse_innovation_covariance);
/* Calculate the optimal Kalman gain.
Note we still have a useful partial product in vertical scratch
from the innovation covariance. */
multiply_matrix(f.vertical_scratch, f.inverse_innovation_covariance,
f.optimal_gain);
/* Estimate the state */
multiply_matrix(f.optimal_gain, f.innovation,
f.state_estimate);
add_matrix(f.state_estimate, f.predicted_state,
f.state_estimate);
/* Estimate the state covariance */
multiply_matrix(f.optimal_gain, f.observation_model,
f.big_square_scratch);
subtract_from_identity_matrix(f.big_square_scratch);
multiply_matrix(f.big_square_scratch, f.predicted_estimate_covariance,
f.estimate_covariance);
}
void predict(KalmanFilter f) {
f.timestep++;
/* Predict the state */
multiply_matrix(f.state_transition, f.state_estimate,
f.predicted_state);
/* Predict the state estimate covariance */
multiply_matrix(f.state_transition, f.estimate_covariance,
f.big_square_scratch);
multiply_by_transpose_matrix(f.big_square_scratch, f.state_transition,
f.predicted_estimate_covariance);
add_matrix(f.predicted_estimate_covariance, f.process_noise_covariance,
f.predicted_estimate_covariance);
}
// Gradient ascent update for the weights
void rbm::update_weights(float ** weights, float ** delta_weights, float learning_rate, int n, int m, float size_mBatch){
multiply_constant_matrix(delta_weights,learning_rate, n, m);
add_matrix(weights, delta_weights, n, m);
}
// Adds two matrices elementwise and returns a new matrix.
Matrix *add_matrix_func(Matrix *A, Matrix *B) {
Matrix *C = make_matrix(A->rows, A->cols);
add_matrix(A, B, C);
return C;
}
int main(){
double a[ROW * COLUMN] = {
1.0, 2.0, 3.0, 4.0,
5.0, 6.0, 7.0, 8.0,
9.0, 10.0, 11.0, 12.0,
};
double b[ROW * COLUMN] = {
2.0, 3.0, 4.0, 5.0,
6.0, 7.0, 8.0, 9.0,
10.0, 11.0, 12.0, 13.0,
};
double c[ROW * COLUMN] = {0.0};
double d[ROW] = {1.0, 2.0, 3.0};
double e[ROW] = {2.0, 5.0, 7.0};
double f[ROW] = {0.0};
uint32_t i = 0;
uint32_t j = 0;
/*
* test add_matrix
* */
/* show A */
printf("A\n");
for(i = 0; i < ROW; i++){
for(j = 0; j < COLUMN; j++) printf("%15.5lf", a[i * COLUMN + j]);
printf("\n");
}
printf("\n");
/* show B */
printf("B\n");
for(i = 0; i < ROW; i++){
for(j = 0; j < COLUMN; j++) printf("%15.5lf", b[i * COLUMN + j]);
printf("\n");
}
printf("\n");
/* calculate */
add_matrix(a, b, c, ROW, COLUMN);
/* show C */
printf("C = A + B\n");
for(i = 0; i < ROW; i++){
for(j = 0; j < COLUMN; j++) printf("%15.5lf", c[i * COLUMN + j]);
printf("\n");
}
printf("\n");
/*
* test dot_vector
* */
/* show D */
printf("D\n");
for(i = 0; i < ROW; i++) printf("%15.5lf", d[i]);
printf("\n\n");
/* show E */
printf("E\n");
for(i = 0; i < ROW; i++) printf("%15.5lf", e[i]);
printf("\n\n");
/* calculate & show result */
printf("x = D dot E\n");
printf("%15.5lf",dot_vector(d, e, ROW));
printf("\n\n");
/*
* test cross_vector
* */
/* show D */
printf("D\n");
for(i = 0; i < ROW; i++) printf("%15.5lf", d[i]);
printf("\n\n");
/* show E */
printf("E\n");
for(i = 0; i < ROW; i++) printf("%15.5lf", e[i]);
printf("\n\n");
/* calculate */
cross_vector(d, e, f, ROW);
/* show F */
printf("F = D x E\n");
for(i = 0; i < ROW; i++) printf("%15.5lf", f[i]);
printf("\n");
return 0;
}
int main(void)
{
crosslist one,two,three;
int choice;//as a mark of selection
char flag;//selection mark
while(1)
{
system("cls");
system("color 81");
system("mode con cols=80 lines=400");
system("title #Crosslist To Deal With Sparse Matrix#");
printf("\t@*************************************************************@\n");
putchar('\n');
printf("\t\t %c----------稀疏矩阵-应用程序系统----------%c\n",2,2);
putchar('\n');
printf("\t@*************************************************************@\n");
printf("\t$*************************************************************$\n");
printf("\t\t %c----------------功能选择-----------------%c\n",2,2);
putchar('\n');
printf("\t\t %c-----------------------------------------%c\n",2,2);
printf("\t\t %c <1> 稀疏矩阵的加法运算 %c\n",2,2);
printf("\t\t %c-----------------------------------------%c\n",2,2);
printf("\t\t %c <2> 稀疏矩阵的减法运算 %c\n",2,2);
printf("\t\t %c-----------------------------------------%c\n",2,2);
printf("\t\t %c <3> 稀疏矩阵的乘法运算 %c\n",2,2);
printf("\t\t %c-----------------------------------------%c\n",2,2);
printf("\t\t %c <4> 退出应用程序 %c\n",2,2);
printf("\t\t %c-----------------------------------------%c\n",2,2);
putchar('\n');
printf("\t\t %c-----------矩阵以行序为主序-----------%c\n",2,2);
printf("\t$*************************************************************$\n");
printf("\t\t!!注意：如果想终止程序，请按 Ctrl +C\n");
printf("\t$*************************************************************$\n\n");
printf("请输入你的选择:(1--4)\n");
fflush(stdin);//清空输入缓冲区
printf("你的选择是:");
scanf("%d",&choice);
putchar('\n');
switch(choice)
{
case 1: printf("\t<加法运算>\n");
putchar('\n');
init_matrix(one);//初始化矩阵one
printf("\t<建立第一个矩阵>\n");
creat_matrix(one);
putchar('\n');
printf("第一个矩阵如下:\n");
printf("-------------------------------------------------\n");
print_matrix(one);
printf("-------------------------------------------------\n");
init_matrix(two);//初始化矩阵two
putchar('\n');
printf("\t<建立第二个矩阵>\n");
creat_matrix(two);
putchar('\n');
printf("第二个矩阵如下:\n");
printf("-------------------------------------------------\n");
print_matrix(two);
printf("-------------------------------------------------\n");
/*add the two matrix*/
putchar('\n');
printf("两个矩阵相加\n");
init_matrix(three);//初始化矩阵three
putchar('\n');
add_matrix(one,two,three);
printf("结果如下:\n");
printf("-------------------------------------------------\n");
Sleep(1000);
print_matrix(three);
printf("-------------------------------------------------\n");
system("pause");
break;
case 2: printf("\t<减法运算>\n");
putchar('\n');
init_matrix(one);//初始化矩阵one
printf("\t<建立第一个矩阵>\n");
creat_matrix(one);
putchar('\n');
printf("第一个矩阵如下:\n");
printf("-------------------------------------------------\n");
print_matrix(one);
printf("-------------------------------------------------\n");
init_matrix(two);//初始化矩阵two
putchar('\n');
printf("\t<建立第二个矩阵>\n");
creat_matrix(two);
putchar('\n');
printf("第二个矩阵如下:\n");
printf("-------------------------------------------------\n");
print_matrix(two);
printf("-------------------------------------------------\n");
/*add the two matrix*/
putchar('\n');
printf("两个矩阵相减\n");
init_matrix(three);//初始化矩阵three
putchar('\n');
opposite_matrix(two);
add_matrix(one,two,three);
printf("结果如下:\n");
printf("-------------------------------------------------\n");
Sleep(1000);
print_matrix(three);
printf("-------------------------------------------------\n");
system("pause");
break;
case 3: printf("\t<乘法运算>\n");
putchar('\n');
init_matrix(one);//初始化矩阵one
putchar('\n');
printf("\t<建立第一个矩阵>\n");
creat_matrix(one);
putchar('\n');
printf("第一个矩阵如下:\n");
printf("-------------------------------------------------\n");
print_matrix(one);
printf("-------------------------------------------------\n");
init_matrix(two);//初始化矩阵two
putchar('\n');
printf("\t<建立第二个矩阵>\n");
creat_matrix(two);
putchar('\n');
printf("第二个矩阵如下:\n");
printf("-------------------------------------------------\n");
print_matrix(two);
printf("-------------------------------------------------\n");
/*multiply the two matrix*/
putchar('\n');
printf("两个矩阵相乘\n");
init_matrix(three);
multi_matrix(one,two,three);
printf("结果如下:\n");
printf("-------------------------------------------------\n");
Sleep(1000);
print_matrix(three);
printf("-------------------------------------------------\n");
system("pause");
break;
case 4: printf("你确定退出程序吗<Y/N>?\n");
fflush(stdin);
scanf("%c",&flag);
if(flag=='y'||flag=='Y'||flag=='\n')
{
printf("\t\t%c-------%c-------%c-------%c-------%c\n",2,2,2,2,2);
putchar('\n');
printf("\t\t(^_^)谢谢使用!(^_^)\n");
putchar('\n');
printf("\t\t%c-------%c-------%c-------%c-------%c\n",2,2,2,2,2);
putchar('\n');
Sleep(2000);
exit(1);
}
else
{
printf("………欢迎继续使用………\n");
Sleep(2000);
}
break;
default:printf("请输入有效的选择 1 ~ 4!\n");
Sleep(2000);
break;
}//switch
}//while
return 1;
}
FORALLSITES(i, s) {
mult_nn(&(s->link[dir2]), (matrix *)(gen_pt[1][i]), &tmat1);
mult_nn(&tmat1, (matrix *)(gen_pt[2][i]), &tmat2);
mult_na(&tmat2, (matrix *)(gen_pt[0][i]), &tmat1);
add_matrix(&(s->tempmat2), &tmat1, &(s->tempmat2));
}
