int
main (void)
{
GLfloat ini[] = {
1, 2, 3, 0,
4, 1, 6, 0,
7, 8, 9, 0,
0, 0, 0, 0
};
GLfloat inv[16];
GLfloat mat[16];
GLfloat tmp[16];
memset(inv, 0, sizeof(inv));
memset(mat, 0, sizeof(mat));
memset(tmp, 0, sizeof(tmp));
if (matrix_invt3(inv, ini)) {
matrix_print(ini);
matrix_transpose(tmp, inv);
matrix_print(tmp);
matrix_mul(mat, ini, tmp);
matrix_print(mat);
matrix_mul(mat, tmp, ini);
matrix_print(mat);
}
return 0;
}
void extend_edge_fast(struct Matrix_Graph *mat_graph)
{
matrix_mul(mat_graph->tmp_matrix, mat_graph->tmp_matrix, \
mat_graph->tmp_precusor, mat_graph->tmp_precusor, mat_graph->node_num);
matrix_mul(mat_graph->shortest_matrix, mat_graph->tmp_matrix, \
mat_graph->precusor, mat_graph->tmp_precusor, mat_graph->node_num);
}
int main(int argc, char *argv[]){
double mmvalues[] = {2.0,3.0,1.0,1.0,4.0,2.0,2.0,1.0,2.0,1.0,4.0,2.0,2.0,3.0,1.0,1.0,4.0,2.0,2.0,1.0,2.0,1.0,4.0,2.0,5.0,4.0,2.0,2.0,1.0,2.0,\
4.0,2.0,2.0,1.0,2.0,1.0,6.0,3.0,1.0,1.0,4.0,2.0,2.0,1.0,9.0,1.0,4.0,2.0,5.0,4.0,2.0,2.0,1.0,2.0,5.0,5.0,2.0,2.0,1.0,2.0};
matrix_t mm, ma, mb, mc, md, mx, my, mz;
init_matrix(&mm, 'm', 6, 6, mmvalues);
init_matrix(&ma, 'a', 3, 3, NULL);
init_matrix(&mb, 'b', 3, 3, NULL);
init_matrix(&mc, 'c', 3, 3, NULL);
display_matrix(&mm);
display_matrix(&ma);
display_matrix(&mb);
display_matrix(&mc);
free_matrix(&ma);
ma = get_submatrix(&mm, 2, 1, 4, 4);
display_matrix(&ma);
free_matrix(&mb);
mb = get_submatrix(&mm, 3, 2, 4, 4);
display_matrix(&mb);
mx = matrix_mul(&ma, &mb, 'X');
my = square_matrix_mul_recursive(&ma, &mb, 'Y');
mz = square_matrix_mul_strassen(&ma, &mb, 'Z');
printf("the result is \n");
display_matrix(&mx);
display_matrix(&my);
display_matrix(&mz);
ma = get_submatrix(&mm, 1, 2, 6, 1);
mb = get_submatrix(&mm, 2, 1, 1, 6);
display_matrix(&ma);
display_matrix(&mb);
mc = matrix_mul(&mb, &ma, '1');
display_matrix(&mc);
md = matrix_mul(&ma, &mb, 'S');
display_matrix(&md);
free_matrix(&mc);
mc = matrix_scale(&md, 2, '2');
display_matrix(&mc);
free_matrix(&ma);
free_matrix(&mb);
free_matrix(&mc);
free_matrix(&md);
free_matrix(&mx);
free_matrix(&my);
free_matrix(&mz);
return 0;
}//main
// matrix power in A^p in O(log(p))
vector<vector<int>> matrix_pow(const vector<vector<int>>& A, int p)
{
if (p == 1)
return A;
if (p % 2 == 1)
return matrix_mul(A, matrix_pow(A, p - 1));
auto B = matrix_pow(A, p / 2);
return matrix_mul(B, B);
}
mat matrix_mi(mat p1,int k)//¾ØÕóÇóÃÝ
{
if(k==1)
return p1;
if(k&1)
return matrix_mul(matrix_mi(p1,k-1),p1);
else
{
mat t=matrix_mi(p1,k>>1);
return matrix_mul(t,t);
}
}
findNthPower( long long int M[][2] , long long int n )
{
R[0][0]=1;R[0][1]=0;R[1][0]=0;R[1][1]=1;
while(n>0){
if(n%2==1)
{matrix_mul(R,M);
n-=1;}
else
{matrix_mul(M,M);
n /= 2;}
}
}
void matrix_pow(Matrix A,LL n,Matrix res)
{
Matrix a,r;
memcpy(a,A,sizeof(a));
memset(r,0,sizeof(r));
for(int i = 0;i < sz;++i) r[i][i] = 1;
while(n)
{
if(n&1) matrix_mul(r,a,r);
n >>= 1;
matrix_mul(a,a,a);
}
memcpy(res,r,sizeof(r));
}
void matrix_exp(const Matrix &m, u64 e, Matrix &r)
{
if (e == 1) { r = m; return; }
Matrix x;
if (e % 2 == 0) {
matrix_exp(m, e / 2, x);
matrix_mul(x, x, r);
return;
}
matrix_exp(m, e-1, x);
matrix_mul(x, m, r);
}
/*
* When a function want to use the paint associated with a canvas to
* draw, it should call _prepare_paint() can make the paint ready.
* And, call _finish_paint() when the paint is no more used.
*/
static void
_prepare_paint(mbe_t *mbe, SkPaint::Style style) {
SkPaint *paint = mbe->paint;
mbe_pattern_t *ptn = mbe->states->ptn;
SkShader *shader;
co_aix matrix[6];
SkMatrix skmatrix;
paint->setStyle(style);
if(ptn != NULL) {
/* Local matrix of SkShader is a mapping from source pattern to
* user space. Unlikely, for Cairo is a mapping from user space
* to source pattern.
*/
shader = ptn->shader;
matrix_mul(mbe->states->matrix, ptn->matrix, matrix);
MB_MATRIX_2_SKMATRIX(skmatrix, matrix);
shader->setLocalMatrix(skmatrix);
paint->setShader(shader);
}
if(style == SkPaint::kStroke_Style)
paint->setStrokeWidth(CO_AIX_2_SKSCALAR(mbe->states->line_width));
if(ptn != NULL && ptn->has_size)
_prepare_sized_pattern(mbe, ptn);
}
void
vl_idct_stage2_frag_shader(struct vl_idct *idct, struct ureg_program *shader,
unsigned first_input, struct ureg_dst fragment)
{
struct ureg_src l_addr[2], r_addr[2];
struct ureg_dst l[2], r[2];
--first_input;
l_addr[0] = ureg_DECL_fs_input(shader, TGSI_SEMANTIC_GENERIC, first_input + VS_O_L_ADDR0, TGSI_INTERPOLATE_LINEAR);
l_addr[1] = ureg_DECL_fs_input(shader, TGSI_SEMANTIC_GENERIC, first_input + VS_O_L_ADDR1, TGSI_INTERPOLATE_LINEAR);
r_addr[0] = ureg_DECL_fs_input(shader, TGSI_SEMANTIC_GENERIC, first_input + VS_O_R_ADDR0, TGSI_INTERPOLATE_LINEAR);
r_addr[1] = ureg_DECL_fs_input(shader, TGSI_SEMANTIC_GENERIC, first_input + VS_O_R_ADDR1, TGSI_INTERPOLATE_LINEAR);
l[0] = ureg_DECL_temporary(shader);
l[1] = ureg_DECL_temporary(shader);
r[0] = ureg_DECL_temporary(shader);
r[1] = ureg_DECL_temporary(shader);
fetch_four(shader, l, l_addr, ureg_DECL_sampler(shader, 1), false);
fetch_four(shader, r, r_addr, ureg_DECL_sampler(shader, 0), true);
matrix_mul(shader, fragment, l, r);
ureg_release_temporary(shader, l[0]);
ureg_release_temporary(shader, l[1]);
ureg_release_temporary(shader, r[0]);
ureg_release_temporary(shader, r[1]);
}
static struct sprite_trans *
trans_mul(struct sprite_trans *a, struct sprite_trans *b, struct sprite_trans *t, struct matrix *tmp_matrix) {
if (b == NULL) {
return a;
}
*t = *a;
if (t->mat == NULL) {
t->mat = b->mat;
} else if (b->mat) {
matrix_mul(tmp_matrix, t->mat, b->mat);
t->mat = tmp_matrix;
}
if (t->color == 0xffffffff) {
t->color = b->color;
} else if (b->color != 0xffffffff) {
t->color = color_mul(t->color, b->color);
}
if (t->additive == 0) {
t->additive = b->additive;
} else if (b->additive != 0) {
t->additive = color_add(t->additive, b->additive);
}
if (t->program == PROGRAM_DEFAULT) {
t->program = b->program;
}
return t;
}
const GLfloat *
get_mvp (void)
{
static GLfloat mvp[16];
matrix_mul(mvp, ctx_mx_projection_top->mat, ctx_mx_modelview_top->mat);
return mvp;
}
static int lupdate(lua_State *L) {
struct particle_system *ps = (struct particle_system *)lua_touserdata(L, 1);
float dt = (float)luaL_checknumber(L, 2);
struct matrix *anchor = (struct matrix*)lua_touserdata(L, 3);
int edge = (int)luaL_checkinteger(L, 4);
if (ps->config->positionType == POSITION_TYPE_GROUPED) {
ps->config->emitterMatrix = anchor;
} else {
ps->config->emitterMatrix = NULL;
}
ps->config->sourcePosition.x = 0;
ps->config->sourcePosition.y = 0;
particle_system_update(ps, dt);
if (ps->isActive || ps->isAlive) {
int n = ps->particleCount;
int i;
struct matrix tmp;
for (i = 0; i < n; i++) {
struct particle *p = &ps->particles[i];
calc_particle_system_mat(p, &ps->matrix[i], edge);
if (ps->config->positionType != POSITION_TYPE_GROUPED) {
memcpy(tmp.m, &ps->matrix[i], sizeof(int) * 6);
matrix_mul(&ps->matrix[i], &tmp, anchor);
}
p->color_val = color4f(&p->color);
}
lua_pushboolean(L, 1);
} else {
lua_pushboolean(L, 0);
}
return 1;
}
void glScale3f(float x, float y, float z)
{
matrix_t matrix_scale;
matrix_t matrix_res;
transform_scale(&matrix_scale, x, y, z);
matrix_mul(&matrix_main, &matrix_scale, &matrix_res);
matrix_clone(&matrix_main, &matrix_res);
}
static int
llmul(lua_State *L) {
struct matrix *m1 = (struct matrix *)lua_touserdata(L, 1);
struct matrix *m2 = (struct matrix *)lua_touserdata(L, 2);
struct matrix source = *m1;
matrix_mul(m1, m2, &source);
lua_settop(L,1);
return 1;
}
static struct matrix *
mat_mul(struct matrix *a, struct matrix *b, struct matrix *tmp) {
if (b == NULL)
return a;
if (a == NULL)
return b;
matrix_mul(tmp, a , b);
return tmp;
}
void glTransform3f(float x, float y, float z)
{
matrix_t matrix_move;
matrix_t matrix_res;
transform_move(&matrix_move, x, y, z);
matrix_mul(&matrix_main, &matrix_move, &matrix_res);
matrix_clone(&matrix_main, &matrix_res);
}
static int
lmatrix_multi_draw(lua_State *L) {
struct sprite *s = self(L);
int cnt = (int)luaL_checkinteger(L,3);
if (cnt == 0)
return 0;
luaL_checktype(L,4,LUA_TTABLE);
luaL_checktype(L,5,LUA_TTABLE);
if (lua_rawlen(L, 4) < cnt) {
return luaL_error(L, "matrix length must less then particle count");
}
if (lua_rawlen(L, 5) < cnt) {
return luaL_error(L, "color length must less then particle count");
}
struct matrix *mat = (struct matrix *)lua_touserdata(L, 2);
if (s->t.mat == NULL) {
s->t.mat = &s->mat;
matrix_identity(&s->mat);
}
struct matrix *parent_mat = s->t.mat;
uint32_t parent_color = s->t.color;
int i;
if (mat) {
struct matrix tmp;
for (i = 0; i < cnt; i++) {
lua_rawgeti(L, 4, i+1);
lua_rawgeti(L, 5, i+1);
struct matrix *m = (struct matrix *)lua_touserdata(L, -2);
matrix_mul(&tmp, m, mat);
s->t.mat = &tmp;
s->t.color = (uint32_t)lua_tounsigned(L, -1);
lua_pop(L, 2);
sprite_draw(s, NULL);
}
} else {
for (i = 0; i < cnt; i++) {
lua_rawgeti(L, 4, i+1);
lua_rawgeti(L, 5, i+1);
struct matrix *m = (struct matrix *)lua_touserdata(L, -2);
s->t.mat = m;
s->t.color = (uint32_t)lua_tounsigned(L, -1);
lua_pop(L, 2);
sprite_draw(s, NULL);
}
}
s->t.mat = parent_mat;
s->t.color = parent_color;
return 0;
}
void
sprite_matrix(struct sprite * self, struct matrix *mat) {
struct sprite * parent = self->parent;
if (parent) {
assert(parent->type == TYPE_ANIMATION);
sprite_matrix(parent, mat);
struct matrix tmp;
struct matrix * parent_mat = parent->t.mat;
struct matrix * child_mat = NULL;
struct pack_animation *ani = parent->s.ani;
int frame = real_frame(parent) + parent->start_frame;
struct pack_frame * pf = &ani->frame[frame];
int i;
for (i=0;i<pf->n;i++) {
struct pack_part *pp = &pf->part[i];
int index = pp->component_id;
struct sprite * child = parent->data.children[index];
if (child == self) {
child_mat = pp->t.mat;
break;
}
}
if (parent_mat == NULL && child_mat == NULL)
return;
if (parent_mat) {
matrix_mul(&tmp, parent_mat, mat);
} else {
tmp = *mat;
}
if (child_mat) {
matrix_mul(mat, child_mat, &tmp);
} else {
*mat = tmp;
}
} else {
matrix_identity(mat);
}
}
void glRotate3f(float angle, float x, float y, float z)
{
matrix_t matrix_rot_x;
matrix_t matrix_rot_y;
matrix_t matrix_rot_z;
matrix_t matrix_res1;
matrix_t matrix_res2;
matrix_t matrix_res3;
transform_rotate_x(&matrix_rot_x, (2*M_PI/360)*(x*angle));
transform_rotate_y(&matrix_rot_y, (2*M_PI/360)*(y*angle));
transform_rotate_z(&matrix_rot_z, (2*M_PI/360)*(z*angle));
matrix_mul(&matrix_rot_x, &matrix_rot_y, &matrix_res1);
matrix_mul(&matrix_res1, &matrix_rot_z, &matrix_res2);
matrix_mul(&matrix_main, &matrix_res2, &matrix_res3);
matrix_clone(&matrix_main, &matrix_res3);
}
void GLAPIENTRY
imm_MultMatrixf (const GLfloat *m)
{
GLfloat top[16];
FLUSH_VERTICES();
memcpy(top, (*ctx_mx_top)->mat, sizeof(identity));
matrix_mul((*ctx_mx_top)->mat, top, m);
(*ctx_mx_top)->type |= MATRIX_GENERAL;
}
void test_matrix()
{
struct Matrix* m = matrix_generate(5,5);
printf("Matrix null: %d\n", matrix_is_null(m));
matrix_make_identity(m);
struct Matrix* m2 = matrix_copy(m);
matrix_set(m2,1,2,1);
struct Matrix* m3 = matrix_mul(m2,m);
matrix_show(m3);
matrix_free(m);
matrix_free(m2);
matrix_free(m3);
}
void
calc_particle_system_mat(struct particle * p, struct matrix *m, int edge) {
matrix_identity(m);
struct srt srt;
srt.rot = p->rotation * 1024 / 360;
srt.scalex = p->size * 1024 / edge;
srt.scaley = srt.scalex;
srt.offx = (p->pos.x + p->startPos.x) * SCREEN_SCALE;
srt.offy = (p->pos.y + p->startPos.y) * SCREEN_SCALE;
matrix_srt(m, &srt);
matrix_mul(m, m, &p->emitMatrix);
}
void calc_particle_system_mat(struct particle * p, struct matrix *m, int edge) {
struct srt srt;
struct matrix tmp;
matrix_identity(m);
srt.rot = (int)(p->rotation * 1024 / 360);
srt.scalex = (int)(p->size * 1024 / edge);
srt.scaley = srt.scalex;
srt.offx = (int)((p->pos.x + p->startPos.x) * SCREEN_SCALE);
srt.offy = (int)((p->pos.y + p->startPos.y) * SCREEN_SCALE);
matrix_srt(m, &srt);
memcpy(tmp.m, m, sizeof(int) * 6);
matrix_mul(m, &tmp, &p->emitMatrix);
}
int main(int argc, char **argv)
{
double a[N * N], b[N * N], c[N * N] ;
int i, j ;
for (i = 0; i < N; i++) {
for (j = 0; j < N; j++) {
a[i * N + j] = i + j ; b[i * N + j] = i - j ;
}
}
matrix_mul(c, a, b, N) ;
print_matrix(a, N) ; printf("\n") ;
print_matrix(b, N) ; printf("\n") ;
print_matrix(c, N) ;
return 0 ;
}
void communication_task(){
int status;
rsc_info.rsc_tab = (struct resource_table *)&resources;
rsc_info.size = sizeof(resources);
zynqMP_r5_gic_initialize();
/* Initialize RPMSG framework */
status = remoteproc_resource_init(&rsc_info, rpmsg_channel_created, rpmsg_channel_deleted,
rpmsg_read_cb ,&proc);
if (status < 0) {
return;
}
#ifdef USE_FREERTOS
comm_queueset = xQueueCreateSet( 2 );
xQueueAddToSet( OpenAMPInstPtr.send_queue, comm_queueset);
xQueueAddToSet( OpenAMPInstPtr.lock, comm_queueset);
#else
env_create_sync_lock(&OpenAMPInstPtr.lock,LOCKED);
#endif
env_enable_interrupt(VRING1_IPI_INTR_VECT, 0, 0);
while (1) {
#ifdef USE_FREERTOS
QueueSetMemberHandle_t xActivatedMember;
xActivatedMember = xQueueSelectFromSet( comm_queueset, portMAX_DELAY);
if( xActivatedMember == OpenAMPInstPtr.lock ) {
env_acquire_sync_lock(OpenAMPInstPtr.lock);
process_communication(OpenAMPInstPtr);
}
if (xActivatedMember == OpenAMPInstPtr.send_queue) {
xQueueReceive( OpenAMPInstPtr.send_queue, &send_data, 0 );
rpmsg_send(app_rp_chnl, send_data.data, send_data.length);
}
#else
env_acquire_sync_lock(OpenAMPInstPtr.lock);
process_communication(OpenAMPInstPtr);
matrix_mul();
if(pq_qlength(OpenAMPInstPtr.send_queue) > 0) {
send_data = pq_dequeue(OpenAMPInstPtr.send_queue);
/* Send the result of matrix multiplication back to master. */
rpmsg_send(app_rp_chnl, send_data->data, send_data->length);
}
#endif
}
}
JobPointer executeJob(JobPointer currentJob){
int JobType = currentJob->JobType;
// large switch
switch(JobType){
case 0:
addsleep(currentJob->params);
break;
case 1:
vectoradd(currentJob->params);
break;
case 2:
printf("Executing - %d\n", omp_get_thread_num());
matrix_mul(currentJob->params);
break;
}
return currentJob;
}
static int
lcalc_matrix(lua_State *L) {
struct sprite * s = self(L);
struct matrix * mat = (struct matrix *)lua_touserdata(L, 2);
if (mat == NULL) {
return luaL_argerror(L, 2, "need a matrix");
}
struct matrix *local_matrix = s->t.mat;
if (local_matrix) {
struct matrix tmp;
sprite_matrix(s, &tmp);
matrix_mul(mat, local_matrix, &tmp);
} else {
sprite_matrix(s, mat);
}
lua_settop(L, 2);
return 1;
}
/**
* Returns new matrix, powering the matrix to the exponent
*/
uint32_t* matrix_pow(const uint32_t* matrix, uint32_t exponent)
{
uint32_t* result = cloned(matrix);
if(exponent==0)
{
result = identity_matrix();
}
else
{
for (int c=0; c<exponent-1 && exponent!=0; c++)
{
result = matrix_mul(result, matrix);
}
}
return result;
}
static int
draw_utf8(int unicode, int cx, int cy, int size, const struct srt *srt,
uint32_t color, const struct sprite_trans *arg) {
const struct dfont_rect * rect = dfont_lookup(Dfont, unicode, FONT_SIZE);
if (rect == NULL) {
return 0;
}
struct matrix tmp;
struct matrix mat1 = {{ 1024,0,0,1024, cx* SCREEN_SCALE, cy*SCREEN_SCALE }};
struct matrix *m;
if (arg->mat) {
m=&tmp;
matrix_mul(m, &mat1, arg->mat);
} else {
m=&mat1;
}
matrix_srt(m, srt);
draw_rect(rect,size,m,color);
return (rect->w-1) * size / FONT_SIZE ;
}
