static void subdiv( union vert *v0, union vert *v1, union vert *v2, GLuint depth ) { if (depth == 0) { glColor3fv(v0->v.color); glVertex3fv(v0->v.pos); glColor3fv(v1->v.color); glVertex3fv(v1->v.pos); glColor3fv(v2->v.color); glVertex3fv(v2->v.pos); } else { union vert m[3]; make_midpoint(&m[0], v0, v1); make_midpoint(&m[1], v1, v2); make_midpoint(&m[2], v2, v0); subdiv(&m[0], &m[2], v0, depth-1); subdiv(&m[1], &m[0], v1, depth-1); subdiv(&m[2], &m[1], v2, depth-1); subdiv(&m[0], &m[1], &m[2], depth-1); } }
void zzn3_div2(_MIPD_ zzn3 *w) { #ifdef MR_OS_THREADS miracl *mr_mip=get_mip(); #endif if (mr_mip->ERNUM) return; MR_IN(188) copy(w->a,mr_mip->w1); if (remain(_MIPP_ mr_mip->w1,2)!=0) add(_MIPP_ mr_mip->w1,mr_mip->modulus,mr_mip->w1); subdiv(_MIPP_ mr_mip->w1,2,mr_mip->w1); copy(mr_mip->w1,w->a); copy(w->b,mr_mip->w1); if (remain(_MIPP_ mr_mip->w1,2)!=0) add(_MIPP_ mr_mip->w1,mr_mip->modulus,mr_mip->w1); subdiv(_MIPP_ mr_mip->w1,2,mr_mip->w1); copy(mr_mip->w1,w->b); copy(w->c,mr_mip->w1); if (remain(_MIPP_ mr_mip->w1,2)!=0) add(_MIPP_ mr_mip->w1,mr_mip->modulus,mr_mip->w1); subdiv(_MIPP_ mr_mip->w1,2,mr_mip->w1); copy(mr_mip->w1,w->c); MR_OUT }
int invmodp(_MIPD_ big a,big p,big z) { #ifdef MR_OS_THREADS miracl *mr_mip=get_mip(); #endif big u,v,x1,x2; MR_IN(213); u=mr_mip->w1; v=mr_mip->w2; x1=mr_mip->w3; x2=mr_mip->w4; copy(a,u); copy(p,v); convert(_MIPP_ 1,x1); zero(x2); while (size(u)!=1 && size(v)!=1) { while (remain(_MIPP_ u,2)==0) { subdiv(_MIPP_ u,2,u); if (remain(_MIPP_ x1,2)!=0) add(_MIPP_ x1,p,x1); subdiv(_MIPP_ x1,2,x1); } while (remain(_MIPP_ v,2)==0) { subdiv(_MIPP_ v,2,v); if (remain(_MIPP_ x2,2)!=0) add(_MIPP_ x2,p,x2); subdiv(_MIPP_ x2,2,x2); } if (mr_compare(u,v)>=0) { mr_psub(_MIPP_ u,v,u); subtract(_MIPP_ x1,x2,x1); } else { mr_psub(_MIPP_ v,u,v); subtract(_MIPP_ x2,x1,x2); } } if (size(u)==1) copy(x1,z); else copy(x2,z); if (size(z)<0) add(_MIPP_ z,p,z); MR_OUT return 1; /* note - no checking that gcd=1 */ }
int main () { /* hailstone numbers */ int iter,r; big x,y,mx; mirsys(400,10); x=mirvar(0); y=mirvar(0); mx=mirvar(0); iter=0; printf("number = \n"); innum(x,stdin); do { /* main loop */ if (compare(x,mx)>0) copy(x,mx); r=subdiv(x,2,y); if (r!=0) { /* what goes up ... */ premult(x,3,x); incr(x,1,x); } /* ... must come down */ else copy(y,x); otnum(x,stdout); iter++; } while (size(x)!=1); printf("path length = %d \n",iter); printf("maximum = \n"); otnum(mx,stdout); return 0; }
t_get *subdivide(char *s, t_get *prev, char **bad_sintax) { size_t l; t_get *link; if (empty(s)) return (prev); if (s[0] == '\\' && prev) if ((!S_IN(prev->word, "\"'|;<>()`"))) return (echappment(s, prev, bad_sintax, 0)); if ((link = xmalloc(sizeof(*prev))) == NULL) return (NULL); link->word = (void*)(link->next = NULL); link->prev = prev; if (prev) prev->next = link; s += hempty(s); if (s[(link->inter = 0)] == '\\') return (echappment(s, link, bad_sintax, 1)); l = subdiv(s, bad_sintax); if (*bad_sintax) return (nullify_link(link, 0, 1)); if ((link->word = my_strndup(s, l)) == NULL) return (nullify_link(link, 0, 1)); if (subdivide(s + my_strlen(link->word), link, bad_sintax) == NULL) return (nullify_link(link, 1, 1)); return (link); }
static void Display( void ) { glClearColor(0.3, 0.3, 0.3, 1); glClear( GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT ); glPointSize(psz); enable( GL_POINT_SMOOTH, pointsmooth ); enable( GL_VERTEX_PROGRAM_POINT_SIZE_ARB, program_point_size ); glBegin(prim); { union vert v[3]; ASSIGN_3V(v[0].v.color, 0,0,1); ASSIGN_3V(v[0].v.pos, 0.9, -0.9, 0.0); ASSIGN_3V(v[1].v.color, 1,0,0); ASSIGN_3V(v[1].v.pos, 0.9, 0.9, 0.0); ASSIGN_3V(v[2].v.color, 0,1,0); ASSIGN_3V(v[2].v.pos, -0.9, 0, 0.0); subdiv(&v[0], &v[1], &v[2], nr_steps); } glEnd(); glFlush(); if (show_fps) { ++frame_cnt; glutPostRedisplay(); } }
static void Display( void ) { glClearColor(0.3, 0.3, 0.3, 1); glClear( GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT ); glUseProgram(program); glBegin(GL_TRIANGLES); { union vert v[3]; ASSIGN_3V(v[0].v.color, 0,0,1); ASSIGN_3V(v[0].v.pos, 0.9, -0.9, 0.0); ASSIGN_3V(v[1].v.color, 1,0,0); ASSIGN_3V(v[1].v.pos, 0.9, 0.9, 0.0); ASSIGN_3V(v[2].v.color, 0,1,0); ASSIGN_3V(v[2].v.pos, -0.9, 0, 0.0); subdiv(&v[0], &v[1], &v[2], nr_steps); } glEnd(); glFlush(); }
ofMesh ofxFaceTracker2Landmarks::getMesh(vector<T> points) const { cv::Rect rect(0, 0, info.inputWidth, info.inputHeight); cv::Subdiv2D subdiv(rect); for(int i=0;i<points.size();i++){ if( rect.contains(points[i]) ){ subdiv.insert(points[i]); } } vector<cv::Vec6f> triangleList; subdiv.getTriangleList(triangleList); ofMesh mesh; mesh.setMode(OF_PRIMITIVE_TRIANGLES); for( size_t i = 0; i < triangleList.size(); i++ ) { cv::Vec6f t = triangleList[i]; cv::Point2f pt1 = cv::Point(cvRound(t[0]), cvRound(t[1])); cv::Point2f pt2 = cv::Point(cvRound(t[2]), cvRound(t[3])); cv::Point2f pt3 = cv::Point(cvRound(t[4]), cvRound(t[5])); // Draw rectangles completely inside the image. if ( rect.contains(pt1) && rect.contains(pt2) && rect.contains(pt3)) { mesh.addVertex(ofxCv::toOf(pt1)); mesh.addVertex(ofxCv::toOf(pt2)); mesh.addVertex(ofxCv::toOf(pt3)); } } return mesh; }
void SoCapsule :: subdiv(std::vector<GsVec>& Q, int degree) { if (degree == 0) { P.push_back(Q[0]); P.push_back(Q[1]); P.push_back(Q[2]); C.push_back(GsColor::blue); C.push_back(GsColor::blue); C.push_back(GsColor::blue); } else { std::vector<GsVec> A; std::vector<GsVec> R; std::vector<GsVec> D; std::vector<GsVec> S; GsVec mid_1 = (Q[0] + Q[1]) / 2; GsVec mid_2 = (Q[1] + Q[2]) / 2; GsVec mid_3 = (Q[2] + Q[0]) / 2; mid_1.normalize(); mid_2.normalize(); mid_3.normalize(); A.push_back(Q[0]); A.push_back(mid_1); A.push_back(mid_3); subdiv(A, degree - 1); R.push_back(Q[1]); R.push_back(mid_1); R.push_back(mid_2); subdiv(R, degree - 1); D.push_back(Q[2]); D.push_back(mid_2); D.push_back(mid_3); subdiv(D, degree - 1); S.push_back(mid_1); S.push_back(mid_2); S.push_back(mid_3); subdiv(S, degree - 1); } }
RowVectorXi findDelaunayTriangulation(Eigen::Ref<const RowVectorX> ileavedPoints) { auto points = toSeparatedViewConst<Scalar>(ileavedPoints); eigen_assert(points.cols() == 2); // Find min max. RowVector2 minC = points.colwise().minCoeff(); RowVector2 maxC = points.colwise().maxCoeff(); // Don't make the bounds too tight. cv::Rect_<float> bounds( std::floor(minC.x() - aam::Scalar(1)), std::floor(minC.y() - aam::Scalar(1)), std::ceil(maxC.x() - minC.x() + aam::Scalar(2)), std::ceil(maxC.y() - minC.y() + aam::Scalar(2))); cv::Subdiv2D subdiv(bounds); std::vector<cv::Point2f> controlPoints; for (MatrixX::Index i = 0; i < points.rows(); ++i) { cv::Point2f c(points(i, 0), points(i, 1)); subdiv.insert(c); controlPoints.push_back(c); } std::vector<cv::Vec6f> triangleList; subdiv.getTriangleList(triangleList); RowVectorXi triangleIds(triangleList.size() * 3); int validTris = 0; for (size_t i = 0; i < triangleList.size(); i++) { cv::Vec6f t = triangleList[i]; cv::Point2f p0(t[0], t[1]); cv::Point2f p1(t[2], t[3]); cv::Point2f p2(t[4], t[5]); if (bounds.contains(p0) && bounds.contains(p1) && bounds.contains(p2)) { auto iter0 = std::find(controlPoints.begin(), controlPoints.end(), p0); auto iter1 = std::find(controlPoints.begin(), controlPoints.end(), p1); auto iter2 = std::find(controlPoints.begin(), controlPoints.end(), p2); triangleIds(validTris * 3 + 0) = (int)std::distance(controlPoints.begin(), iter0); triangleIds(validTris * 3 + 1) = (int)std::distance(controlPoints.begin(), iter1); triangleIds(validTris * 3 + 2) = (int)std::distance(controlPoints.begin(), iter2); ++validTris; } } return triangleIds.leftCols(validTris * 3); }
void fpmul(_MIPD_ flash x,int n,int d,flash y) { /* multiply x by small fraction n/d - y=x*n/d */ int r,g; #ifdef MR_OS_THREADS miracl *mr_mip=get_mip(); #endif if (mr_mip->ERNUM) return; if (n==0 || size(x)==0) { zero(y); return; } if (n==d) { copy(x,y); return; } MR_IN(42) if (d<0) { d=(-d); n=(-n); } numer(_MIPP_ x,mr_mip->w1); denom(_MIPP_ x,mr_mip->w2); r=subdiv(_MIPP_ mr_mip->w1,d,mr_mip->w3); g=igcd(d,r); r=subdiv(_MIPP_ mr_mip->w2,n,mr_mip->w3); g*=igcd(n,r); mr_mip->check=OFF; premult(_MIPP_ mr_mip->w1,n,mr_mip->w5); premult(_MIPP_ mr_mip->w2,d,mr_mip->w6); subdiv(_MIPP_ mr_mip->w5,g,mr_mip->w5); subdiv(_MIPP_ mr_mip->w6,g,mr_mip->w6); mr_mip->check=ON; if (fit(mr_mip->w5,mr_mip->w6,mr_mip->nib)) fpack(_MIPP_ mr_mip->w5,mr_mip->w6,y); else mround(_MIPP_ mr_mip->w5,mr_mip->w6,y); MR_OUT }
Geometry& subdivide(Geometry& geo, int amount) { while (amount--) { Geometry subdivided; subdivided.positions.reserve(geo.positions.size() * 4); subdivided.texcoords.reserve(geo.texcoords.size() * 4); subdivided.normals.reserve(geo.normals.size() * 4); subdivided.quads.reserve(geo.quads.size() * 4); for (const auto& quad : geo.quads) { uint base = subdivided.positions.size(); subdiv(quad, subdivided.positions, geo.positions); subdiv(quad, subdivided.texcoords, geo.texcoords); subdiv(quad, subdivided.normals, geo.normals); subdivided.quads.emplace_back(base + 0, base + 1, base + 8, base + 7); subdivided.quads.emplace_back(base + 1, base + 2, base + 3, base + 8); subdivided.quads.emplace_back(base + 8, base + 3, base + 4, base + 5); subdivided.quads.emplace_back(base + 7, base + 8, base + 5, base + 6); } geo = std::move(subdivided); normalizeNormals(geo); } return geo; }
void SoCapsule::build(float len, float rt, float rb, int degree) { P.clear(); C.clear(); P.reserve(18); C.reserve(18); // reserve space to avoid re-allocations from the calls below // circle radius rt, vetex at cos, sin, -len/2 double thetaInc = M_PI /2; for (double p = 0; p < 2* M_PI ; p += thetaInc) { for (double d = 0; d < 2 * M_PI; d += thetaInc) { std::vector<GsVec> Q; Q.push_back(GsVec(cos(d)*sin(p), sin(d)*sin(p), cos(p))); Q.push_back(GsVec(cos(d+ thetaInc)*sin(p), sin(d+ thetaInc)*sin(p), cos(p))); Q.push_back(GsVec(cos(d)*sin(p + thetaInc), sin(d)*sin(p + thetaInc), cos(p + thetaInc))); subdiv(Q, degree); std::vector<GsVec> S; S.push_back(GsVec(cos(d + thetaInc)*sin(p+thetaInc), sin(d + thetaInc)*sin(p+thetaInc), cos(p+thetaInc))); S.push_back(GsVec(cos(d + thetaInc)*sin(p), sin(d + thetaInc)*sin(p), cos(p))); S.push_back(GsVec(cos(d)*sin(p + thetaInc), sin(d)*sin(p + thetaInc), cos(p + thetaInc))); subdiv(S, degree); } } // circle radius rb, vertex at cos, sin, len/2 // send data to OpenGL buffers: glBindBuffer(GL_ARRAY_BUFFER, buf[0]); glBufferData(GL_ARRAY_BUFFER, P.size() * 3 * sizeof(float), &P[0], GL_STATIC_DRAW); glBindBuffer(GL_ARRAY_BUFFER, buf[1]); glBufferData(GL_ARRAY_BUFFER, C.size() * 4 * sizeof(gsbyte), &C[0], GL_STATIC_DRAW); _numpoints = P.size(); P.resize(0); C.resize(0); }
int delaunay2( int argc, char** argv ) { cv::CommandLineParser parser(argc, argv, "{help h||}"); if (parser.has("help")) { help(); return 0; } Scalar active_facet_color(0, 0, 255), delaunay_color(255,255,255); Rect rect(0, 0, 600, 600); Subdiv2D subdiv(rect); Mat img(rect.size(), CV_8UC3); img = Scalar::all(0); string win = "Delaunay Demo"; imshow(win, img); for( int i = 0; i < 200; i++ ) { Point2f fp( (float)(rand()%(rect.width-10)+5), (float)(rand()%(rect.height-10)+5)); locate_point( img, subdiv, fp, active_facet_color ); imshow( win, img ); if( waitKey( 100 ) >= 0 ) break; subdiv.insert(fp); img = Scalar::all(0); draw_subdiv( img, subdiv, delaunay_color ); imshow( win, img ); if( waitKey( 100 ) >= 0 ) break; } img = Scalar::all(0); paint_voronoi( img, subdiv ); imshow( win, img ); waitKey(0); return 0; }
ZZn& ZZn::operator/=(int i) { if (i==1) return *this; if (i==2) { // make a special effort... modulus is odd copy(fn,get_mip()->w1); if (remain(get_mip()->w1,2)!=0) add(get_mip()->w1,get_mip()->modulus,get_mip()->w1); subdiv(get_mip()->w1,2,get_mip()->w1); copy(get_mip()->w1,fn); return *this; } ZZn x=i; nres_moddiv(fn,x.fn,fn); return *this; }
void getprime(char *fname) { /* get prime details from file */ FILE *fp; int i; fp=fopen(fname,"r"); fscanf(fp,"%d\n",&np); for (i=0;i<np;i++) cinnum(pp[i],fp); fclose(fp); convert(1,p1); for (i=0;i<np;i++) multiply(p1,pp[i],p1); incr(p1,1,p); if (!isprime(p)) { printf("Huh - modulus is not prime!"); exit(0); } subdiv(p,3,lim1); premult(lim1,2,lim2); }
BOOL factored(long lptr,big T) { /* factor quadratic residue */ BOOL facted; int i,j,r,st; partial=FALSE; facted=FALSE; for (j=1;j<=mm;j++) { /* now attempt complete factorisation of T */ r=(int)(lptr%epr[j]); if (r<0) r+=epr[j]; if (r!=r1[j] && r!=r2[j]) continue; while (subdiv(T,epr[j],XX)==0) { /* cast out epr[j] */ e[j]++; copy(XX,T); } st=size(T); if (st==1) { facted=TRUE; break; } if (size(XX)<=epr[j]) { /* st is prime < epr[mm]^2 */ if (st>=MR_TOOBIG || (st/epr[mm])>(1+mlf/50)) break; if (st<=epr[mm]) for (i=j;i<=mm;i++) if (st==epr[i]) { e[i]++; facted=TRUE; break; } if (facted) break; lp=st; /* factored with large prime */ partial=TRUE; facted=TRUE; break; } } return facted; }
int main() { FILE *fp; big q,p,p1,h,t,g,low,high; big pool[POOL_SIZE]; BOOL fail; int i,j,p1bits,np; long seed,m,permutation; miracl *mip=mirsys(100,0); q=mirvar(0); p=mirvar(0); h=mirvar(0); t=mirvar(0); g=mirvar(0); p1=mirvar(0); low=mirvar(0); high=mirvar(0); gprime(10000); /* randomise */ printf("Enter 9 digit random number seed = "); scanf("%ld",&seed); getchar(); irand(seed); p1bits=PBITS-QBITS-1; /* find number of primes pa, pb, pc etc., that will be needed */ np=1; while (p1bits/np >= OBITS) np++; np--; /* find the high/low limits for these primes, so that the generated prime p will be exactly PBITS in length */ expb2(p1bits-1,t); nroot(t,np,low); /* np-th integer root */ incr(low,1,low); premult(t,2,t); decr(t,1,t); nroot(t,np,high); subtract(high,low,t); /* raise low limit up to half-way... */ subdiv(t,2,t); subtract(high,t,low); /* generate q */ forever { /* make sure leading two bits of q 11... */ expb2(QBITS,q); bigbits(QBITS-2,t); subtract(q,t,q); nxprime(q,q); if (logb2(q)>QBITS) continue; break; } printf("q= (%d bits)\n",logb2(q)); cotnum(q,stdout); /* generate prime pool from which permutations of np primes will be picked until a Lim-Lee prime is found */ for (i=0;i<POOL_SIZE;i++) { /* generate the primes pa, pb, pc etc.. */ pool[i]=mirvar(0); forever { bigrand(high,p1); if (mr_compare(p1,low)<0) continue; nxprime(p1,p1); if (mr_compare(p1,high)>0) continue; copy(p1,pool[i]); break; } } /* The '1' bits in the permutation indicate which primes are picked from the pool. If np=5, start at 11111, then 101111 etc */ permutation=1L; for (i=0;i<np;i++) permutation<<=1; permutation-=1; /* permuation = 2^np-1 */ /* generate p */ fail=FALSE; forever { convert(1,p1); for (i=j=0,m=1L;j<np;i++,m<<=1) { if (i>=POOL_SIZE) { /* ran out of primes... */ fail=TRUE; break; } if (m&permutation) { multiply(p1,pool[i],p1); j++; } } if (fail) break; printf("."); premult(q,2,p); multiply(p,p1,p); incr(p,1,p); permutation=increment(permutation); if (logb2(p)!=PBITS) continue; if (isprime(p)) break; } if (fail) { printf("\nFailed - very unlikely! - try increasing POOL_SIZE\n"); return 0; } printf("\np= (%d bits)\n",logb2(p)); cotnum(p,stdout); /* finally find g */ do { decr(p,1,t); bigrand(t,h); divide(t,q,t); powmod(h,t,p,g); } while(size(g)==1); printf("g= (%d bits)\n",logb2(g)); cotnum(g,stdout); fp=fopen("common.dss","wt"); fprintf(fp,"%d\n",PBITS); mip->IOBASE=16; cotnum(p,fp); cotnum(q,fp); cotnum(g,fp); fclose(fp); return 0; }
int main() { /* decode using private key */ int i; big e,ep[NP],m,ke,kd,p[NP],kp[NP],mn,mx; FILE *ifile; FILE *ofile; char ifname[13],ofname[13]; BOOL flo; big_chinese ch; mip=mirsys(100,0); for (i=0;i<NP;i++) { p[i]=mirvar(0); ep[i]=mirvar(0); kp[i]=mirvar(0); } e=mirvar(0); m=mirvar(0); kd=mirvar(0); ke=mirvar(0); mn=mirvar(0); mx=mirvar(0); mip->IOBASE=60; if ((ifile=fopen("private.key","r"))==NULL) { printf("Unable to open file private.key\n"); return 0; } for (i=0;i<NP;i++) { cinnum(p[i],ifile); } fclose(ifile); /* generate public and private keys */ convert(1,ke); for (i=0;i<NP;i++) { multiply(ke,p[i],ke); } for (i=0;i<NP;i++) { /* kp[i]=(2*(p[i]-1)+1)/3 = 1/3 mod p[i]-1 */ decr(p[i],1,kd); premult(kd,2,kd); incr(kd,1,kd); subdiv(kd,3,kp[i]); } crt_init(&ch,NP,p); nroot(ke,3,mn); multiply(mn,mn,m); multiply(mn,m,mx); subtract(mx,m,mx); do { /* get input file */ printf("file to be decoded = "); gets(ifname); } while (strlen(ifname)==0); strip(ifname); strcat(ifname,".rsa"); printf("output filename = "); gets(ofname); flo=FALSE; if (strlen(ofname)>0) { /* set up output file */ flo=TRUE; ofile=fopen(ofname,"w"); } printf("decoding message\n"); if ((ifile=fopen(ifname,"r"))==NULL) { printf("Unable to open file %s\n",ifname); return 0; } forever { /* decode line by line */ mip->IOBASE=60; cinnum(m,ifile); if (size(m)==0) break; for (i=0;i<NP;i++) powmod(m,kp[i],p[i],ep[i]); crt(&ch,ep,e); /* Chinese remainder thereom */ if (compare(e,mx)>=0) divide(e,mn,mn); mip->IOBASE=128; if (flo) cotnum(e,ofile); cotnum(e,stdout); } crt_end(&ch); fclose(ifile); if (flo) fclose(ofile); printf("message ends\n"); return 0; }
int main() { int i; FILE *fp; big K,rid,id,w,a,b,n,q1; miracl *mip=mirsys(200,256); for (i=0;i<NPRIMES;i++) { pp[i]=mirvar(0); rem[i]=mirvar(0); } w=mirvar(0); n=mirvar(0); a=mirvar(0); b=mirvar(0); p=mirvar(0); p1=mirvar(0); q1=mirvar(0); K=mirvar(0); lim1=mirvar(0); lim2=mirvar(0); id=mirvar(0); rid=mirvar(0); order=mirvar(0); printf("Enter ID= "); innum(rid,stdin); getprime("trap1.dat"); copy(p,n); getprime("trap2.dat"); multiply(n,p,n); printf("\ncomposite =\n"); cotnum(n,stdout); premult(rid,256,id); while (jack(id,n)!=1) { /* bad identity - id=256*rid+i */ printf("No Discrete Log. for this ID -- incrementing\n"); incr(id,1,id); } getprime("trap1.dat"); copy(p1,q1); pollard(id,b); getprime("trap2.dat"); pollard(id,a); xgcd(p1,q1,K,K,K); subtract(b,a,w); mad(w,K,w,q1,q1,w); if(size(w)<0) add_r(w,q1,w); subdiv(w,2,w); multiply(w,p1,w); add_r(w,a,w); fp=fopen("secret.dat","w"); otnum(rid,fp); cotnum(w,fp); cotnum(n,fp); fclose(fp); printf("\nDiscrete log (secret key) \n"); cotnum(w,stdout); powltr(PROOT,w,n,id); subdiv(id,256,id); otstr(id,mip->IOBUFF); printf("Check Identity= %s\n",mip->IOBUFF); return 0; }
double Triangulate::performDelaunay(int x, int y, int w, int h, const vector<point_2d_t> &points, vector<triangle_t> *triangles) { //cout << "performDelaunay" << endl; triangles->clear(); Rect rect(x,y,w,h); Subdiv2D subdiv(rect); for( int i = 0; i < points.size(); i++ ) { //cout << i << " : [" << points[i].pos[0] << ", " << points[i].pos[1] << "]" << endl; Point2f fp(points[i].pos[0], points[i].pos[1]); subdiv.insert(fp); } vector<Vec6f> triangleList; subdiv.getTriangleList(triangleList); vector<Point> pt(3); vector<triangle_t> triangleIndList; float tol = 0.000001; double area = 0.; for( size_t i = 0; i < triangleList.size(); i++ ) { bool f1 = false; bool f2 = false; bool f3 = false; triangle_t tri; Vec6f t = triangleList[i]; pt[0] = Point(cvRound(t[0]), cvRound(t[1])); pt[1] = Point(cvRound(t[2]), cvRound(t[3])); pt[2] = Point(cvRound(t[4]), cvRound(t[5])); for(int j = 0; j < points.size(); ++j) { //cout << "x = " << points[j].pos[0] << ", y = " << points[j].pos[1] << endl; if(abs(points[j].pos[0] - pt[0].x) < tol && abs(points[j].pos[1] - pt[0].y) < tol) { tri.ind[0] = j; f1 = true; } else if(abs(points[j].pos[0] - pt[1].x) < tol && abs(points[j].pos[1] - pt[1].y) < tol) { tri.ind[1] = j; f2 = true; } else if(abs(points[j].pos[0] - pt[2].x) < tol && abs(points[j].pos[1] - pt[2].y) < tol) { tri.ind[2] = j; f3 = true; } } if(f1 && f2 && f3) { triangles->push_back(tri); area += abs(t[0]*(t[3] - t[5]) + t[2]*(t[5] - t[1]) + t[4]*(t[1] - t[3]))/2; } } return area; }
int main(int argc, char **argv) { char *infile, *outfile; struct model *or_model, *sub_model=NULL; int lev, nlev=1, rcode, nonopt_argc=1; int sub_method=-1, use_binary=0; struct subdiv_methods sm={BUTTERFLY_SUBDIV_FUNCTIONS, LOOP_SUBDIV_FUNCTIONS, SPHERICAL_OR_SUBDIV_FUNCTIONS, SPHERICAL_ALT_SUBDIV_FUNCTIONS, KOBBELTSQRT3_SUBDIV_FUNCTIONS}; struct subdiv_functions *tmp_func=NULL; if (argc < 4 || argc > 6) { fprintf(stderr, "Usage: subdiv [-sph_or, -sph_alt, -but, -loop, -ksqrt3][-bin]" " infile outfile n_lev\n"); exit(1); } for (nonopt_argc=1; nonopt_argc<=2; nonopt_argc++) { #ifdef DEBUG printf("argv[%d] = %s\n", nonopt_argc, argv[nonopt_argc]); #endif if (strcmp(argv[nonopt_argc], "-sph_or") == 0) { tmp_func = &(sm.spherical_or); sub_method = SUBDIV_SPH_OR; } else if (strcmp(argv[nonopt_argc], "-sph_alt") == 0) { tmp_func = &(sm.spherical_alt); sub_method = SUBDIV_SPH_ALT; } else if (strcmp(argv[nonopt_argc], "-but") == 0) { tmp_func = &(sm.butterfly); sub_method = SUBDIV_BUTTERFLY; } else if (strcmp(argv[nonopt_argc], "-loop") == 0) { tmp_func = &(sm.loop); sub_method = SUBDIV_LOOP; } else if (strcmp(argv[nonopt_argc], "-ksqrt3") == 0) sub_method = SUBDIV_KOB_SQRT3; else if (strcmp(argv[nonopt_argc], "-bin") == 0) use_binary = 1; else break; } if (sub_method == -1) { fprintf(stderr, "Invalid subdivision method\n"); fprintf(stderr, "Usage: subdiv [-sph_or, -sph_alt, -but, -loop, -ksqrt3][-bin]" " infile outfile n_lev\n"); exit(1); } infile = argv[nonopt_argc]; outfile = argv[++nonopt_argc]; if (argc == nonopt_argc+2) nlev = atoi(argv[++nonopt_argc]); if (nlev < 1) nlev = 1; rcode = read_fmodel(&or_model, infile, MESH_FF_AUTO, 0); if (rcode < 0) { fprintf(stderr, "Unable to read model - error code %d\n", rcode); exit(-1); } for (lev=0; lev<nlev; lev++) { /* performs the subdivision */ switch (sub_method) { case SUBDIV_KOB_SQRT3: /* handle sqrt3 stuff separately */ sub_model = subdiv_sqrt3(or_model, &(sm.kob_sqrt3)); break; default: /* 4-to-1 split */ sub_model = subdiv(or_model, tmp_func); break; } __free_raw_model(or_model); or_model = sub_model; } write_raw_model(sub_model, outfile, use_binary); __free_raw_model(sub_model); return 0; }
int main() { /* encode using public key */ big e,m,y,ke,mn,mx; FILE *ifile; FILE *ofile; static char line[500]; static char buff[256]; char ifname[13],ofname[13]; BOOL fli,last; int i,ipt,klen; mip=mirsys(100,0); e=mirvar(0); m=mirvar(0); y=mirvar(0); ke=mirvar(0); mn=mirvar(0); mx=mirvar(0); if ((ifile=fopen("public.key","rt"))==NULL) { printf("Unable to open file public.key\n"); return 0; } mip->IOBASE=16; cinnum(ke,ifile); fclose(ifile); nroot(ke,3,mn); multiply(mn,mn,m); multiply(mn,m,mx); subtract(mx,m,mx); klen=0; copy(mx,m); while (size(m)>0) { /* find key length in characters */ klen++; subdiv(m,128,m); } klen--; printf("file to be encoded = "); gets(ifname); fli=FALSE; if (strlen(ifname)>0) fli=TRUE; if (fli) { /* set up input file */ strcpy(ofname,ifname); strip(ofname); strcat(ofname,".rsa"); if ((ifile=fopen(ifname,"rt"))==NULL) { printf("Unable to open file %s\n",ifname); return 0; } printf("encoding message\n"); } else { /* accept input from keyboard */ ifile=stdin; do { printf("output filename = "); gets(ofname); } while (strlen(ofname)==0); strip(ofname); strcat(ofname,".rsa"); printf("input message - finish with cntrl z\n"); } ofile=fopen(ofname,"wt"); ipt=0; last=FALSE; while (!last) { /* encode line by line */ if (fgets(&line[ipt],132,ifile)==NULL) last=TRUE; if (line[ipt]==EOF) last=TRUE; ipt=strlen(line); if (ipt<klen && !last) continue; while (ipt>=klen) { /* chop up into klen-sized chunks and encode */ for (i=0;i<klen;i++) buff[i]=line[i]; buff[klen]='\0'; for (i=klen;i<=ipt;i++) line[i-klen]=line[i]; ipt-=klen; mip->IOBASE=128; cinstr(m,buff); power(m,3,ke,e); mip->IOBASE=16; cotnum(e,ofile); } if (last && ipt>0) { /* now deal with left overs */ mip->IOBASE=128; cinstr(m,line); if (compare(m,mn)<0) { /* pad out with random number if necessary */ bigrand(mn,y); multiply(mn,mn,e); subtract(e,y,e); multiply(mn,e,y); add(m,y,m); } power(m,3,ke,e); mip->IOBASE=16; cotnum(e,ofile); } } fclose(ofile); if (fli) fclose(ifile); return 0; }
int MakeBoxDomains(const Box &box,int nproc, int nx, int ny, int nz, inp_it result){ int ndir[3]={nx,ny,nz}, nspl[3]={nx,ny,nz}; int np=(nproc>0 ? nproc : -nproc); int startdir=2; int dd, curdir=-1; // getting minimal splits int nauto=0, autod[3]={-1, -1, -1}, ndef=0; for(dd=0;dd<3;dd++){ int dir=(dd+startdir)%3; if(ndir[dir]>0 && ndir[dir]>curdir)curdir=dir; else if(ndir[dir]<0){ autod[nauto++]=dir; } if(ndir[dir]==0)ndef++; } if(curdir<0 && nauto>0){ if(nauto==1){ ndir[autod[0]]=np; curdir=autod[0]; } else{ // auto-finding direction and number of slices to split int i; vec_type lprod=1.; for(i=0;i<nauto;i++){ lprod*=box.GetSize()[autod[i]]; } vec_type k=pow((vec_type)np/lprod,vec_type(1)/vec_type(nauto)); int mnp=0, mdir=0; for(i=0;i<nauto;i++){ int tnp=(int)(box.GetSize()[autod[i]]*k); if(mnp<tnp){ mnp=tnp; mdir=i; } } if(mnp>0){ ndir[autod[mdir]]=mnp; curdir=autod[mdir]; } } } if(curdir>=0){ // splitting by minimal dir, auto split is ignored // number of domains int ndom=0; // determining sub-nps // THIS IS NP SWITCH : !!! if(np<ndir[curdir])ndir[curdir]=np; if(np>ndir[curdir] && ndef==2){ // the last axis ndir[curdir]=np; } int snp=(np>ndir[curdir] ? np : ndir[curdir]); int mnp=snp/ndir[curdir]; // minimal np int dntot=snp%ndir[curdir]; // difference vec_type c0=(vec_type)mnp/snp, c1=(vec_type)(mnp+1)/snp; Vector_3 p1=box.get_p1(); Vector_3 p2=box.get_p2(); vec_type l=box.GetSize()[curdir]; int i; for(i=0;i<ndir[curdir];i++){ vec_type dl=(dntot>0 ? l*c1 : l*c0); int cnp=(dntot>0 ? mnp+1 : mnp); if(cnp<=0)break; dntot--; p2[curdir]=p1[curdir]+dl; Box subdiv(p1,p2); nspl[curdir]=0; // this direction is processed int ddom=MakeBoxDomains(subdiv,(nproc>0 ? cnp: -cnp),nspl[0],nspl[1],nspl[2],result); if(nproc>0)result+=ddom; ndom+=ddom; p1[curdir]=p2[curdir]; } return ndom; } /// called with (0,0,0) split: put this box into the set if(nproc>0) *result=box; return 1; }
int operator%(const Big& b, int i) {Big mdbi; return(subdiv(b.fn,i, mdbi.fn));}
Big operator/(const Big& b, int i) {Big dbi; subdiv(b.fn, i, dbi.fn); return dbi;}
int main() { /* Pollard's lambda algorithm for finding discrete logs * * which are known to be less than a certain limit LIMIT */ big x,n,t,trap,table[32]; int i,j,m; long dm,dn,s,distance[32]; miracl *mip=mirsys(50,0); x=mirvar(0); n=mirvar(0); t=mirvar(0); trap=mirvar(0); for (s=1L,m=1;;m++) { /* find table size */ distance[m-1]=s; s*=2; if ((2*s/m)>(LEAPS/4)) break; } mip->IOBASE=60; /* get large modulus */ cinstr(n,modulus); mip->IOBASE=10; printf("solve discrete logarithm problem - using Pollard's kangaroos\n"); printf("finds x in y=%d^x mod n, given y, for fixed n and small x\n",ALPHA); printf("known to be less than %ld\n",LIMIT); printf("n= "); cotnum(n,stdout); for (i=0;i<m;i++) { /* create table */ lgconv(distance[i],t); table[i]=mirvar(0); powltr(ALPHA,t,n,table[i]); } lgconv(LIMIT,t); powltr(ALPHA,t,n,x); printf("setting trap .... \n"); for (dn=0L,j=0;j<LEAPS;j++) { /* set traps beyond LIMIT using tame kangaroo */ i=subdiv(x,m,t); /* random function */ mad(x,table[i],x,n,n,x); dn+=distance[i]; } printf("trap set!\n"); copy(x,trap); forever { /* ready to solve */ printf("Enter x= "); cinnum(x,stdin); if (size(x)<=0) break; powltr(ALPHA,x,n,t); printf("y= "); cotnum(t,stdout); copy(t,x); for (dm=0L;;) { /* unlease wild kangaroo - boing - boing ... */ i=subdiv(x,m,t); mad(x,table[i],x,n,n,x); dm+=distance[i]; if (compare(x,trap)==0 || dm>LIMIT+dn) break; } if (dm>LIMIT+dn) { /* trap stepped over */ printf("trap failed\n"); continue; } printf("Gotcha!\n"); printf("Discrete log of y= %ld\n",LIMIT+dn-dm); } return 0; }