int main() {
Matrix *A = make_matrix(3, 4);
consecutive_matrix(A);
printf("A\n");
print_matrix(A);
Matrix *C = add_matrix_func(A, A);
printf("A + A\n");
print_matrix(C);
Matrix *B = make_matrix(4, 3);
increment_matrix(B, 1);
printf("B\n");
print_matrix(B);
Matrix *D = mult_matrix_func(A, B);
printf("D\n");
print_matrix(D);
destroy_matrix(A);
destroy_matrix(B);
destroy_matrix(C);
destroy_matrix(D);
return 0;
}
void test_cgm(char *cfgfile, char *weightfile, char *session)
{
char *base = basecfg(cfgfile);
printf("%s\n", base);
network net = parse_network_cfg(cfgfile);
load_weights(&net, weightfile);
freopen("out.txt", "w", stdout);
int input_len = net.w;
int stride = net.w/4;
int i,j,k;
data train;
train.shallow = 0;
train.X = make_matrix(128, net.w*net.h*net.c);
train.y = make_matrix(128, 1);
float cbuf[4096*16];
int cidx = 0;
int cnt = 0;
int cntstride = 0;
int freq[16] = {0};
FILE *fp = fopen(session, "rb");
if(!fp) file_error(session);
while (!feof(fp))
{
unsigned short bytes[11];
fread(bytes, 2, 11, fp);
float fbytes[2];
fread(fbytes, 4, 2, fp);
// put into circular buffer
for (j=0;j<10;j++)
cbuf[cidx+(j<<12)] = (float)(bytes[j])/65536.f;
cidx = (1+cidx)&4095;
cnt++;
cntstride++;
if (fbytes[0]>54 && cnt>input_len && cntstride>stride)
{
cntstride = 0;
train.y.vals[0][0] = (fbytes[0]-50)/200.0;
for (k=0;k<net.w;k++)
for (j=0;j<10;j++)
{
train.X.vals[0][(j*net.w)+k] = cbuf[(j<<12)+(((cidx-1-net.w+k)+4096)&4095)];
}
float *p = network_predict(net, train.X.vals[0]);
// fprintf(stderr, "%f, %f\n", train.y.vals[0][0], p[0]);
p[0] = (p[0]*200.0)+50.0;
fprintf(stdout, "%f, %f\n", fbytes[0], p[0]);
fprintf(stderr, "%f, %f\n", fbytes[0], p[0]);
}
}
fclose(fp);
free_network(net);
free_data(train);
}
Dtype* strassen_make_M2_submatrix(
const unsigned int m,
const unsigned int n,
const unsigned int k,
const Dtype *A_2_1, const int incRowA_2_1,
const Dtype *A_2_2, const int incRowA_2_2,
const Dtype *B_1_1, const int incRowB_1_1){
/*
construct M2 by the formula
M2 = (A_2_1 + A_2_2) * B_1_1
*/
// T1 = A_2_1 + A_2_2
Dtype* T1 = make_matrix(m, k);
matrix_addition(m, k,
A_2_1, incRowA_2_1,
A_2_2, incRowA_2_2,
T1, k);
Dtype* M2 = make_matrix(m, k);
strassen_mm_worker(
m, n, k,
T1, k,
B_1_1, incRowB_1_1,
M2, k);
remove_matrix(T1);
return M2;
}
Dtype* strassen_make_M4_submatrix(
const unsigned int m,
const unsigned int n,
const unsigned int k,
const Dtype *A_2_2, const int incRowA_2_2,
const Dtype *B_2_1, const int incRowB_2_1,
const Dtype *B_1_1, const int incRowB_1_1){
/*
construct M4 by the formula
M4 = A_2_2 * (B_2_1 - B_1_1)
*/
Dtype* T1 = make_matrix(m, k);
// T1 = B_2_1 - B_1_1
matrix_subtraction(m, k,
B_2_1, incRowB_2_1,
B_1_1, incRowB_1_1,
T1, k);
Dtype* M4 = make_matrix(m, k);
strassen_mm_worker(
m, n, k,
A_2_2, incRowA_2_2,
T1, k,
M4, k);
remove_matrix(T1);
return M4;
}
Dtype* strassen_make_M5_submatrix(
const unsigned int m,
const unsigned int n,
const unsigned int k,
const Dtype *A_1_1, const int incRowA_1_1,
const Dtype *A_1_2, const int incRowA_1_2,
const Dtype *B_2_2, const int incRowB_2_2){
/*
construct M5 by the formula
M5 = (A_1_1 + A_1_2) * B_2_2
*/
// T1 = A_1_1 + A_1_2
Dtype* T1 = make_matrix(m, k);
matrix_addition(m, k,
A_1_1, incRowA_1_1,
A_1_2, incRowA_1_2,
T1, k);
Dtype* M5 = make_matrix(m, k);
strassen_mm_worker(
m, n, k,
T1, k,
B_2_2, incRowB_2_2,
M5, k);
remove_matrix(T1);
return M5;
}
Dtype* strassen_make_M3_submatrix(
const unsigned int m,
const unsigned int n,
const unsigned int k,
const Dtype *A_1_1, const int incRowA_1_1,
const Dtype *B_1_2, const int incRowB_1_2,
const Dtype *B_2_2, const int incRowB_2_2){
/*
construct M3 by the formula
M3 = A_1_1 * (B_1_2 - B_2_2)
*/
// T1 = B_1_2 - B_2_2
Dtype* T1 = make_matrix(m, k);
matrix_subtraction(m, k,
B_1_2, incRowB_1_2,
B_2_2, incRowB_2_2,
T1, k);
Dtype* M3 = make_matrix(m, k);
strassen_mm_worker(
m, n, k,
A_1_1, incRowA_1_1,
T1, k,
M3, k);
remove_matrix(T1);
return M3;
}
// Find the solution v to
// u = Mv
const float4 cramers(const float4x4 &m, const float4& u)
{
float4 a = { determinant(make_matrix(u, m.c2, m.c3, m.c4)),
determinant(make_matrix(m.c1, u, m.c3, m.c4)),
determinant(make_matrix(m.c1, m.c2, u, m.c4)),
determinant(make_matrix(m.c1, m.c2, m.c3, u)) };
return (1.0f / determinant(m)) * a;
}
const float3 cramers(const float3x3& m, const float3& u)
{
float3 a =
{
determinant(make_matrix(u, m.c2, m.c3)),
determinant(make_matrix(m.c1, u, m.c3)),
determinant(make_matrix(m.c1, m.c2, u))
};
return (1.0f / determinant(m)) * a;
}
int main() {
int i;
Matrix *A = make_matrix(3, 4);
consecutive_matrix(A);
printf("A\n");
print_matrix(A);
Matrix *C = add_matrix_func(A, A);
printf("A + A\n");
print_matrix(C);
Matrix *B = make_matrix(4, 3);
increment_matrix(B, 1);
printf("B\n");
print_matrix(B);
Matrix *D = mult_matrix_func(A, B);
printf("D\n");
print_matrix(D);
double sum = matrix_sum1(A);
printf("sum = %lf\n", sum);
sum = matrix_sum2(A);
printf("sum = %lf\n", sum);
printf("A\n");
print_matrix(A);
double *sums = row_sum(A);
for (i=0; i<A->rows; i++) {
printf("row %d\t%lf\n", i, sums[i]);
}
// should print 6, 22, 38
double *sums2 = col_sum(A);
for (i=0; i<A->cols; i++) {
printf("col %d\t%lf\n", i, sums2[i]);
}
Matrix *E = make_matrix(3, 3);
E->data[0][0] = 2; E->data[0][1] = 7; E->data[0][2] = 6;
E->data[1][0] = 9; E->data[1][1] = 5; E->data[1][2] = 1;
E->data[2][0] = 4; E->data[2][1] = 3; E->data[2][2] = 8;
printf("E\n");
print_matrix(E);
printf("Magic matrix?: %d \n", is_magic_square(E));
return 0;
}
static SkPathEffect* make_path_effect(bool canBeNull = true) {
SkPathEffect* pathEffect = nullptr;
if (canBeNull && (R(3) == 1)) { return pathEffect; }
switch (R(9)) {
case 0:
pathEffect = SkArcToPathEffect::Create(make_scalar(true));
break;
case 1: {
SkAutoTUnref<SkPathEffect> outer(make_path_effect(false));
SkAutoTUnref<SkPathEffect> inner(make_path_effect(false));
pathEffect = SkComposePathEffect::Create(outer, inner);
break;
}
case 2:
pathEffect = SkCornerPathEffect::Create(make_scalar());
break;
case 3: {
int count = R(10);
SkScalar intervals[10];
for (int i = 0; i < count; ++i) {
intervals[i] = make_scalar();
}
pathEffect = SkDashPathEffect::Create(intervals, count, make_scalar());
break;
}
case 4:
pathEffect = SkDiscretePathEffect::Create(make_scalar(), make_scalar());
break;
case 5:
pathEffect = SkPath1DPathEffect::Create(make_path(),
make_scalar(),
make_scalar(),
make_path_1d_path_effect_style());
break;
case 6:
pathEffect = SkLine2DPathEffect::Create(make_scalar(), make_matrix());
break;
case 7:
pathEffect = SkPath2DPathEffect::Create(make_matrix(), make_path());
break;
case 8:
default:
pathEffect = SkSumPathEffect::Create(make_path_effect(false),
make_path_effect(false));
break;
}
return pathEffect;
}
const float4x4 float4x4::operator + (const float4x4& m)
{
return make_matrix(c1 + m.c1,
c2 + m.c2,
c3 + m.c3,
c4 + m.c4);
}
const float4x4 float4x4::operator * (const float4x4& b) const
{
#if 1
// a textbook implementation...
float4x4 c;
const float4x4 &a = *this;
for (int i = 1; i <= 4; ++i)
{
for (int k = 1; k <= 4; ++k)
{
c(i, k) = a(i, 1) * b(1, k)
+ a(i, 2) * b(2, k)
+ a(i, 3) * b(3, k)
+ a(i, 4) * b(4, k);
}
}
return c;
#else
// assuredly slow, since row() does a lot of logic...
return make_matrix(dot(row(0), m.c1), dot(row(0), m.c2), dot(row(0), m.c3), dot(row(0), m.c4),
dot(row(1), m.c1), dot(row(1), m.c2), dot(row(1), m.c3), dot(row(1), m.c4),
dot(row(2), m.c1), dot(row(2), m.c2), dot(row(2), m.c3), dot(row(2), m.c4),
dot(row(3), m.c1), dot(row(3), m.c2), dot(row(3), m.c3), dot(row(3), m.c4));
#endif
}
void GetGridBox(const CViewPoint *view_point, CBox &ext){
gp_Pnt sp[4];
double zval = 0.5;
wxSize size = wxGetApp().m_current_viewport->GetViewportSize();
sp[0] = gp_Pnt(0, 0, zval);
sp[1] = gp_Pnt(size.GetWidth(), 0, zval);
sp[2] = gp_Pnt(size.GetWidth(), size.GetHeight(), zval);
sp[3] = gp_Pnt(0, size.GetHeight(), zval);
gp_Vec vx, vy;
view_point->GetTwoAxes(vx, vy, false, 0);
gp_Pnt datum(0, 0, 0);
gp_Trsf orimat = wxGetApp().GetDrawMatrix(false);
datum.Transform(orimat);
orimat = make_matrix(datum, vx, vy);
gp_Pln plane(datum, gp_Vec(0, 0, 1).Transformed(orimat));
{
for(int i =0; i<4; i++){
gp_Pnt p1 = view_point->glUnproject(sp[i]);
sp[i].SetZ(0);
gp_Pnt p2 = view_point->glUnproject(sp[i]);
gp_Lin line = make_line(p1, p2);
gp_Pnt pnt;
if(intersect(line, plane, pnt))
{
ext.Insert(pnt.X(), pnt.Y(), pnt.Z());
}
}
}
}
matrix_t
matrix_gen_sym (int size, double sparsity, double ra, double rb,
double diagonal, int pattern)
{
double tmp;
int i, j, k;
matrix_t m = NULL;
int chance = 1 / sparsity;
bool bWrite = FALSE;
m = make_matrix (size, size);
k = 0;
for (j = 0; j < m->cn; j++) {
for (i = k; i < m->rn; i++) {
if ((bWrite = (rand () % chance == 0) ? TRUE : FALSE)) {
tmp =
(ra + (rb - ra) * ((double) rand () / (double) RAND_MAX));
if (pattern)
tmp = floor (tmp);
matrix_put (m, i, j, tmp);
}
if (i == j)
matrix_put (m, i, j, diagonal);
}
k++;
}
matrix_symmetrize (m);
return m;
}
void Run(){
gp_Pln plane;
face_for_tools->GetPlaneParams(plane);
gp_Dir x_direction = plane.XAxis().Direction();
gp_Dir y_direction = plane.YAxis().Direction();
if(face_for_tools->Face().Orientation()== TopAbs_REVERSED)
{
// swap the axes to invert the normal
y_direction = plane.XAxis().Direction();
x_direction = plane.YAxis().Direction();
}
gp_Trsf face_matrix = make_matrix(plane.Location(), x_direction, y_direction);
gp_Trsf inv_matrix = face_matrix.Inverted();
wxGetApp().StartHistory();
double m[16];
extract(face_matrix.Inverted(), m);
// if any objects are selected, move them
if(wxGetApp().m_marked_list->list().size() > 0)
{
for(std::list<HeeksObj *>::iterator It = wxGetApp().m_marked_list->list().begin(); It != wxGetApp().m_marked_list->list().end(); It++)
{
HeeksObj* object = *It;
wxGetApp().TransformUndoably(object, m);
}
}
else
{
// move the solid
HeeksObj* parent_body = face_for_tools->GetParentBody();
if(parent_body)wxGetApp().TransformUndoably(parent_body, m);
}
wxGetApp().EndHistory();
}
/* pomnoz dwie matrixe i zwroc do matrix wynikowa lub NULL w razie bledu */
matrix_t
matrix_mul (matrix_t a, matrix_t b)
{
int i, j, k;
matrix_t mret;
if (a->rn != b->cn) {
fprintf (stderr, "! matrixe nieprawidlowych rozmiarow.");
return NULL;
}
if (!(mret = make_matrix (b->rn, b->cn)))
return NULL;
for (i = 0; i < b->cn; i++) {
for (j = 0; j < b->rn; j++) {
matrix_insert (mret, i, j, 0);
for (k = 0; k < a->cn; k++) {
mret->p[i][j] += a->p[k][i] * b->p[j][k];
}
}
}
return mret;
}
const float4x4 transpose(const float4x4 &m)
{
return make_matrix(m.c1[0], m.c1[1], m.c1[2], m.c1[3],
m.c2[0], m.c2[1], m.c2[2], m.c2[3],
m.c3[0], m.c3[1], m.c3[2], m.c3[3],
m.c4[0], m.c4[1], m.c4[2], m.c4[3]);
}
void make_spl (points_t * pts, spline_t * spl){
int n = pts->n - 1;
matrix_t *eqs = make_matrix(n*3, n*3+1);
double *x = pts->x;
double *y = pts->y;
int i;
for(i= 0; i < n; i++){
double dx = x[i+1] - x[i];
int if1 = 3*i;
int if2 = if1+1;
int if3 = if2+1;
put_entry_matrix(eqs, if1, if1, dx);
put_entry_matrix(eqs, if1, if2, dx*dx/2);
put_entry_matrix(eqs, if1, if3, dx*dx*dx/6);
put_entry_matrix(eqs, if1, n*3, y[i+1]-y[i]);
put_entry_matrix(eqs, if2, if1, 1);
put_entry_matrix(eqs, if2, if2, dx);
put_entry_matrix(eqs, if2, if3, dx*dx/2);
if(if3+1 < n*3)
put_entry_matrix(eqs, if2, if3+1, -1);
else
put_entry_matrix(eqs, if2, if1, 0);
put_entry_matrix(eqs, if3, if2, 1);
put_entry_matrix(eqs, if3, if3, dx);
if(if3+2 < n*3)
put_entry_matrix(eqs, if3, if3+2, -1);
}
#ifdef DEBUG
write_matrix(eqs, stdout);
#endif
if(piv_ge_solver(eqs)) {
spl->n = 0;
return;
}
#ifdef DEBUG
write_matrix(eqs, stdout);
#endif
if(alloc_spl(spl, pts->n) == 0){
spl->n = pts->n;
for(i = 0; i < n; i++) {
spl->x[i] = pts->x[i];
spl->f[i] = pts->y[i];
spl->f1[i] = get_entry_matrix(eqs, 3*i, 3*n);
spl->f2[i] = get_entry_matrix(eqs, 3*i+1, 3*n);
spl->f3[i] = get_entry_matrix(eqs, 3*i+2, 3*n);
}
spl->x[n] = pts->x[n];
spl->f[n] = pts->y[n];
spl->f1[n] = spl->f1[n-1];
spl->f2[n] = 0;
spl->f3[n] = 0;
}
}
int main() {
int i;
Matrix *A = make_matrix(3, 4);
consecutive_matrix(A);
printf("A\n");
print_matrix(A);
Matrix *C = add_matrix_func(A, A);
printf("A + A\n");
print_matrix(C);
Matrix *B = make_matrix(4, 3);
increment_matrix(B, 1);
printf("B\n");
print_matrix(B);
Matrix *D = mult_matrix_func(A, B);
printf("D\n");
print_matrix(D);
double sum = matrix_sum1(A);
printf("sum(A) = %lf\n", sum);
sum = matrix_sum2(A);
printf("sum2(A) = %lf\n", sum);
double *sums = row_sum(A);
for (i=0; i<A->rows; i++) {
printf("row %d\t%lf\n", i, sums[i]);
}
// should print 6, 22, 38
Matrix *E = make_matrix(3,3);
increment_matrix(E, 1);
printf("\nE ");
if (is_magic_square(E)) {
printf("is magic! Whizzam!\n");
} else {
printf("isn't magic...\n");
}
print_matrix(E);
return 0;
}
Matrix make_identity(){
Matrix matrix = make_matrix();
zero_matrix(matrix);
for(int i=0; i<4; i++){
matrix[i][i] = 1;
}
return matrix;
}
void CFace::ModifyByMatrix(const double *m){
if(GetParentBody() == NULL)
{
gp_Trsf mat = make_matrix(m);
BRepBuilderAPI_Transform myBRepTransformation(m_topods_face,mat);
m_topods_face = TopoDS::Face(myBRepTransformation.Shape());
}
}
void Gripper::ModifyByMatrix(const double *m){
gp_Trsf mat = make_matrix(m);
gp_Pnt position(m_data.m_x, m_data.m_y, m_data.m_z);
position.Transform(mat);
m_data.m_x = position.X();
m_data.m_y = position.Y();
m_data.m_z = position.Z();
}
int main() {
int i;
Matrix *A = make_matrix(3, 4);
consecutive_matrix(A);
printf("A\n");
print_matrix(A);
Matrix *C = add_matrix_func(A, A);
printf("A + A\n");
print_matrix(C);
Matrix *B = make_matrix(4, 3);
increment_matrix(B, 1);
printf("B\n");
print_matrix(B);
Matrix *D = mult_matrix_func(A, B);
printf("D\n");
print_matrix(D);
double sum = matrix_sum1(A);
printf("sum = %lf\n", sum);
sum = matrix_sum2(A);
printf("sum = %lf\n", sum);
double *sums = row_sum(A);
for (i=0; i<A->rows; i++) {
printf("row %d\t%lf\n", i, sums[i]);
}
// should print 6, 22, 38
//Test matrix
Matrix *E = make_matrix(3, 3);
increment_matrix(E, 1);
int magic1 = is_magic_square(A); //Not Magic
int magic2 = is_magic_square(B); //Not Magic
int magic3 = is_magic_square(E); //Magic
printf("Magic Matrix result: %d , %d , %d \n", magic1, magic2, magic3);
return 0;
}
void HImage::ModifyByMatrix(const double *m)
{
gp_Trsf mat = make_matrix(m);
for(int i = 0; i<4; i++){
gp_Pnt vt = make_point(m_x[i]);
extract(vt.Transformed(mat), m_x[i]);
}
}
//==========================================================================
void ImplicitizeCurveAlgo::perform()
//==========================================================================
{
// Create barycentric coordinate system
create_bary_coord_system2D(curve_, bc_);
// Convert spline curve to barycentric coordinates
SplineCurve crv_bc;
cart_to_bary(curve_, bc_, crv_bc);
// Check if the curve has a single segment
bool single_segment = (curve_.order() == curve_.numCoefs());
// Make the matrix of numerical coefficients (the D-matrix). Any
// vector in the nullspace of this matrix will be a solution.
vector<vector<double> > mat;
if (single_segment) {
make_matrix(crv_bc, deg_, mat);
} else {
// The matrices from all the segments are stacked on top of each
// other
vector<SplineCurve> segments;
GeometryTools::splitCurveIntoSegments(crv_bc, segments);
int num = (int)segments.size();
make_matrix(segments[0], deg_, mat);
vector<vector<double> > tmp;
for (int i = 1; i < num; ++i) {
make_matrix(segments[i], deg_, tmp);
mat.insert(mat.end(), tmp.begin(), tmp.end());
}
}
// Find the nullspace and construct the implicit function.
vector<double> b;
make_implicit_gauss(mat, b);
// We boldly assume there is no error for the Gaussian elimination
sigma_min_ = 0.0;
// Set the coefficients
implicit_ = BernsteinTriangularPoly(deg_, b);
return;
}
Matrix copy_matrix(Matrix original){
Matrix result = make_matrix();
for(int i=0; i<4; i++){
for(int j=0; j<4; j++){
result[i][j] = original[i][j];
}
}
return result;
}
Matrix multiply(Matrix first, Matrix second){
Matrix result = make_matrix();
for(int i=0; i<4; i++){
for(int j=0; j<4; j++){
result[i][j] = calculate_cell(first, second, i, j);
}
}
return result;
}
//==========================================================================
void ImplicitizeSurfaceAlgo::perform()
//==========================================================================
{
// Create barycentric coordinate system
create_bary_coord_system3D(surf_, bc_);
// Convert spline curve to barycentric coordinates
SplineSurface surf_bc;
cart_to_bary(surf_, bc_, surf_bc);
// Check if the surface has a single patch
bool single_patch = (surf_.order_u() == surf_.numCoefs_u()
&& surf_.order_v() == surf_.numCoefs_v());
// Make the matrix of numerical coefficients (the D-matrix). Any
// vector in the nullspace of this matrix will be a solution.
vector<vector<double> > mat;
if (single_patch) {
make_matrix(surf_bc, deg_, mat);
} else {
// The matrices from all the patches are stacked on top of each
// other
vector<SplineSurface> patches;
GeometryTools::splitSurfaceIntoPatches(surf_bc, patches);
int num = (int)patches.size();
make_matrix(patches[0], deg_, mat);
vector<vector<double> > tmp;
for (int i = 1; i < num; ++i) {
make_matrix(patches[i], deg_, tmp);
mat.insert(mat.end(), tmp.begin(), tmp.end());
}
}
// Find the nullspace and construct the implicit function.
vector<double> b;
make_implicit_svd(mat, b, sigma_min_);
// Set the coefficients
implicit_ = BernsteinTetrahedralPoly(deg_, b);
return;
}
static sk_sp<SkPathEffect> make_path_effect(bool canBeNull = true) {
sk_sp<SkPathEffect> pathEffect;
if (canBeNull && (R(3) == 1)) { return pathEffect; }
switch (R(8)) {
case 0:
pathEffect = SkPath2DPathEffect::Make(make_matrix(), make_path());
break;
case 1:
pathEffect = SkPathEffect::MakeCompose(make_path_effect(false),
make_path_effect(false));
break;
case 2:
pathEffect = SkCornerPathEffect::Make(make_scalar());
break;
case 3: {
int count = R(10);
SkScalar intervals[10];
for (int i = 0; i < count; ++i) {
intervals[i] = make_scalar();
}
pathEffect = SkDashPathEffect::Make(intervals, count, make_scalar());
break;
}
case 4:
pathEffect = SkDiscretePathEffect::Make(make_scalar(), make_scalar());
break;
case 5:
pathEffect = SkPath1DPathEffect::Make(make_path(), make_scalar(), make_scalar(),
make_path_1d_path_effect_style());
break;
case 6:
pathEffect = SkLine2DPathEffect::Make(make_scalar(), make_matrix());
break;
case 7:
default:
pathEffect = SkPathEffect::MakeSum(make_path_effect(false),
make_path_effect(false));
break;
}
return pathEffect;
}
matrix_t
matrix_copy (matrix_t a)
{
int i, j;
matrix_t m = NULL;
m = make_matrix (a->rn, a->cn);
for (j = 0; j < a->cn; j++)
for (i = 0; i < a->rn; i++)
matrix_put (m, i, j, matrix_get (a, i, j));
return m;
}
