自学教程：C++ tri函数代码示例

/*private*/boolOffsetCurveSetBuilder::isTriangleErodedCompletely(	const CoordinateSequence *triangleCoord, double bufferDistance){	Triangle tri(triangleCoord->getAt(0), triangleCoord->getAt(1), triangleCoord->getAt(2));	Coordinate inCentre;	tri.inCentre(inCentre);	double distToCentre=CGAlgorithms::distancePointLine(inCentre, tri.p0, tri.p1);	bool ret = distToCentre < std::fabs(bufferDistance);	return ret;}

void BaseWalls(trix_mesh *mwhite, trix_mesh *mblack, trix_vertex *v, int x, int y, int w, int h) {		// west	if (x == 0) {		quad(mwhite, &v[17], &v[21], &v[18], &v[14]);		quad(mblack, &v[0], &v[17], &v[14], &v[1]);	}		// east	if (x + 1 == w) {		quad(mwhite, &v[15], &v[19], &v[20], &v[16]);		quad(mblack, &v[4], &v[15], &v[16], &v[5]);	}		// north	if (y == 0) {				tri(mwhite, &v[17], &v[29], &v[21]);		tri(mwhite, &v[29], &v[20], &v[21]);		tri(mwhite, &v[16], &v[20], &v[29]);				quad(mblack, &v[0], &v[27], &v[29], &v[17]);		quad(mblack, &v[27], &v[5], &v[16], &v[29]);	}		// south	if (y + 1 == h) {		tri(mwhite, &v[14], &v[18], &v[28]);		tri(mwhite, &v[28], &v[18], &v[19]);		tri(mwhite, &v[15], &v[28], &v[19]);				quad(mblack, &v[1], &v[14], &v[28], &v[26]);		quad(mblack, &v[28], &v[15], &v[4], &v[26]);	}}

LayerTileSet LayerTileSet::fromLayer(const Layer &layer){	const QVector<Tile> tiles = layer.tiles();	const int cols = Tile::roundTiles(layer.width());	Q_ASSERT(!tiles.isEmpty());	QVector<TileRun> runs;	// First, Run Length Encode the tile vector	runs << TileRun { tiles.first(), 0, 0, 1, tiles.first().solidColor() };	for(int i=1;i<tiles.size();++i) {		if(runs.last().len < 0xffff && runs.last().tile.equals(tiles.at(i))) {			runs.last().len++;		} else {			runs << TileRun { tiles.at(i), i%cols, i/cols, 1, tiles.at(i).solidColor() };		}	}	// Count the number of solid color tiles.	QHash<quint32, int> colors;	for(const TileRun &tr : runs) {		if(tr.color.isValid())			colors[tr.color.rgba()] += tr.len;	}	// If half of the tiles are of the same	// solid color, use that as the background color.	// Otherwise, transparency is a safe default choice.	QColor background = Qt::transparent;	const int treshold = tiles.length() / 2;	for(QHash<quint32, int>::const_iterator i = colors.constBegin();i!=colors.constEnd();++i) {		if(i.value() >= treshold) {			background = QColor::fromRgba(i.key());			break;		}	}	// Remove solid color tiles that match the background	QMutableVectorIterator<TileRun> tri(runs);	while(tri.hasNext()) {		if(tri.next().color == background)			tri.remove();	}	// All done!	return LayerTileSet {		runs,		background	};}

voidQvisTurnDownButton::paintEvent(QPaintEvent *e){    QPushButton::paintEvent(e);    QPainter paint(this);    QPolygon tri(3);    tri.setPoint(0, width()/2, height()*2/3);    tri.setPoint(1, width()-4, height()*1/3);    tri.setPoint(2, 4, height()*1/3);    paint.setBrush(palette().text());    paint.drawConvexPolygon(tri);}

std::vector<Triangle2D> ConvexPolygon::Triangulate() const{	int numVerts = GetNumVertices();	const Vec2 *vertices = GetVertices();		std::vector<Triangle2D> ret;	for(int i = 2;i < numVerts;i++)	{		Triangle2D tri(vertices[0],vertices[i - 1],vertices[i]);		ret.push_back(tri);	}	return ret;}

static void omp_force (sotl_device_t *dev){  sotl_atom_set_t *set = &dev->atom_set;  tri(set);  #pragma omp parallel num_threads(NB_THREAD )  #pragma omp for schedule(static)  for (int current = 0; current < (int)set->natoms; current++) {    calc_t force[3] = { 0.0, 0.0, 0.0 };    //atome Z supperieur    for(int other = current-1;other>-1;other--){	if(abs(set->pos.z[current]-set->pos.z[other]) > LENNARD_SQUARED_CUTOFF){		break;	}else{		calc_t sq_dist = squared_distance (set, current, other);		if (sq_dist < LENNARD_SQUARED_CUTOFF) {	  		calc_t intensity = lennard_jones (sq_dist);	  		force[0] += intensity * (set->pos.x[current] - set->pos.x[other]);	  		force[1] += intensity * (set->pos.x[set->offset + current] -						 set->pos.x[set->offset + other]);	 		force[2] += intensity * (set->pos.x[set->offset * 2 + current] -				   		 set->pos.x[set->offset * 2 + other]);		}	}    }    //atome Z inferieur    for(int other = current+1;other<(int)set->natoms;other++){	if(abs(set->pos.z[current]-set->pos.z[other]) > LENNARD_SQUARED_CUTOFF){		break;	}else{		calc_t sq_dist = squared_distance (set, current, other);		if (sq_dist < LENNARD_SQUARED_CUTOFF) {	  		calc_t intensity = lennard_jones (sq_dist);	  		force[0] += intensity * (set->pos.x[current] - set->pos.x[other]);		  	force[1] += intensity * (set->pos.x[set->offset + current] -				   		 set->pos.x[set->offset + other]);			force[2] += intensity * (set->pos.x[set->offset * 2 + current] -						 set->pos.x[set->offset * 2 + other]);	}	}    }    set->speed.dx[current] += force[0];    set->speed.dx[set->offset + current] += force[1];    set->speed.dx[set->offset * 2 + current] += force[2];	  }}

int main(){  int currtri = 285;  int currpen = 165;  int currhex = 143;  currtri++;  currpen++;  currhex++;  while (currtri != currpen || 	 currpen != currhex || 	 currtri != currhex)    {           if ( hex(currhex) < tri(currtri) || 		hex(currhex) < pen(currpen) )	{	  currhex++;	}      else if ( pen(currpen) < tri(currtri) || 		pen(currpen) < hex(currhex) )	{	  currpen++;	}      else if ( tri(currtri) < pen(currpen) || 		tri(currtri) < hex(currhex) )	{	  currtri++;	}      else	{	  printf("e");	  break;	}    }  printf("/n%d, %d, %d/n", tri(currtri), pen(currpen), hex(currhex));  return 0;}

int main(){	int i,n=10000000,tringl,c;	for(i=1;i<=n;i++)	{		tringl=tri(i);		c = factor(tringl);		if(c>500)			break;		printf("%d triangle %d have %d factor/n",i,tringl,c);	}	printf("+ %d have %d factor/n",tringl,c);	return 0;}

void trmm(int rows=internal::random<int>(1,EIGEN_TEST_MAX_SIZE),          int cols=internal::random<int>(1,EIGEN_TEST_MAX_SIZE),          int otherCols = OtherCols==Dynamic?internal::random<int>(1,EIGEN_TEST_MAX_SIZE):OtherCols){  typedef typename NumTraits<Scalar>::Real RealScalar;  typedef Matrix<Scalar,Dynamic,Dynamic,TriOrder> TriMatrix;  typedef Matrix<Scalar,Dynamic,OtherCols,OtherCols==1?ColMajor:OtherOrder> OnTheRight;  typedef Matrix<Scalar,OtherCols,Dynamic,OtherCols==1?RowMajor:OtherOrder> OnTheLeft;    typedef Matrix<Scalar,Dynamic,OtherCols,OtherCols==1?ColMajor:ResOrder> ResXS;  typedef Matrix<Scalar,OtherCols,Dynamic,OtherCols==1?RowMajor:ResOrder> ResSX;  TriMatrix  mat(rows,cols), tri(rows,cols), triTr(cols,rows);    OnTheRight  ge_right(cols,otherCols);  OnTheLeft   ge_left(otherCols,rows);  ResSX       ge_sx, ge_sx_save;  ResXS       ge_xs, ge_xs_save;  Scalar s1 = internal::random<Scalar>(),         s2 = internal::random<Scalar>();  mat.setRandom();  tri = mat.template triangularView<Mode>();  triTr = mat.transpose().template triangularView<Mode>();  ge_right.setRandom();  ge_left.setRandom();  VERIFY_IS_APPROX( ge_xs = mat.template triangularView<Mode>() * ge_right, tri * ge_right);  VERIFY_IS_APPROX( ge_sx = ge_left * mat.template triangularView<Mode>(), ge_left * tri);    VERIFY_IS_APPROX( ge_xs.noalias() = mat.template triangularView<Mode>() * ge_right, tri * ge_right);  VERIFY_IS_APPROX( ge_sx.noalias() = ge_left * mat.template triangularView<Mode>(), ge_left * tri);    VERIFY_IS_APPROX( ge_xs.noalias() = (s1*mat.adjoint()).template triangularView<Mode>() * (s2*ge_left.transpose()), s1*triTr.conjugate() * (s2*ge_left.transpose()));  VERIFY_IS_APPROX( ge_sx.noalias() = ge_right.transpose() * mat.adjoint().template triangularView<Mode>(), ge_right.transpose() * triTr.conjugate());    VERIFY_IS_APPROX( ge_xs.noalias() = (s1*mat.adjoint()).template triangularView<Mode>() * (s2*ge_left.adjoint()), s1*triTr.conjugate() * (s2*ge_left.adjoint()));  VERIFY_IS_APPROX( ge_sx.noalias() = ge_right.adjoint() * mat.adjoint().template triangularView<Mode>(), ge_right.adjoint() * triTr.conjugate());    ge_xs_save = ge_xs;  VERIFY_IS_APPROX( (ge_xs_save + s1*triTr.conjugate() * (s2*ge_left.adjoint())).eval(), ge_xs.noalias() += (s1*mat.adjoint()).template triangularView<Mode>() * (s2*ge_left.adjoint()) );  ge_sx_save = ge_sx;  VERIFY_IS_APPROX( ge_sx_save - (ge_right.adjoint() * (-s1 * triTr).conjugate()).eval(), ge_sx.noalias() -= (ge_right.adjoint() * (-s1 * mat).adjoint().template triangularView<Mode>()).eval());    VERIFY_IS_APPROX( ge_xs = (s1*mat).adjoint().template triangularView<Mode>() * ge_left.adjoint(), internal::conj(s1) * triTr.conjugate() * ge_left.adjoint());    // TODO check with sub-matrix expressions ?}

int main()   {   init_graphics();           //initialize graphics system   circle cir(40, 12, 5, cBLUE, X_FILL);      //create circle   rect rec(12, 7, 10, 15, cRED, SOLID_FILL); //create rectangle   tria tri(60, 7,  11, cGREEN, MEDIUM_FILL); //create triangle   cir.draw();                //draw all shapes   rec.draw();   tri.draw();   set_cursor_pos(1, 25);     //lower left corner   return 0;   }

//-----------------------------------------------------------------------------bool SimpleMesh::AddFace(const std::vector<Vector3<float> > &verts){  unsigned int ind1, ind2, ind3;  AddVertex(verts.at(0), ind1);  AddVertex(verts.at(1), ind2);  AddVertex(verts.at(2), ind3);  Face tri(ind1, ind2, ind3);  mFaces.push_back(tri);  // Compute and assign a normal  mFaces.back().normal = FaceNormal(mFaces.size() - 1);  return true;}

int main(void){    t_case grille[N][N];    t_score Liste[1000];    int tailleListe;    generation(grille);    printf("/n/n/t  RUZZLE SOLVER/n");    afficher_matrice(grille);    points = trouverListe(grille);    tri(Liste, &tailleListe);    printf("Voici la liste des mots trouve dans la grille et leur nombre de points :/n");    afficher_liste(tailleListe, Liste);void test(void){ 	CU_ASSERT_EQUAL(points, 21); }

void ModelDisp::AddModel(gui::Base * obj,gui::Event * event){ // First load a 3d model...  sur::Mesh * mesh;  str::String fn;  if (cyclops.App().LoadFileDialog("Load .ply/.obj mesh file","*.ply,*.obj",fn)==false) return;  time::Progress * prog = cyclops.BeginProg();  prog->Report(0,3);  mesh = file::LoadMesh(fn,prog);  if (mesh==null<sur::Mesh*>())  {   cyclops.App().MessageDialog(gui::App::MsgErr,"Failed to load mesh");   cyclops.EndProg();   return;  } // Then triangulate...  prog->Report(1,3);  mesh->Triangulate(); // Then iterate all triangles...  prog->Report(2,3);  ds::Array<sur::Face> face;  mesh->GetFaces(face);  ds::Array<sur::Vertex> tri(3);  prog->Push();   for (nat32 i=0;i<face.Size();i++)   {    prog->Report(i,face.Size());    face[i].GetVertices(tri);    makeDisp.Add(tri[0].Pos(),tri[1].Pos(),tri[2].Pos());   }  prog->Pop();  cyclops.EndProg(); // Clean up and redraw...  delete mesh;  RenderDisp();  canvas->Redraw();}

    vector<int> getRow(int rowIndex) {		vector<vector<int>> tri(rowIndex+1,vector<int>());		if (tri.size()==0)return vector<int>();		tri[0].push_back(1);		for (int i=1;i<tri.size();i++){			vector<int> row(i+1);			std::swap(tri[i],row);			tri[i][0]=1;			for (int j=1;j<tri[i].size()-1;j++){				tri[i][j]=tri[i-1][j-1]+tri[i-1][j];			}			tri[i][tri[i].size()-1]=1;		}		return tri[tri.size()-1];    }

QStringList TextOdt::getCible(int max_word, bool tri_police, bool tri_size){    for(int i=0; i < m_textCibles.size();i++)        delete m_textCibles[i];    m_textCibles.clear();    extract_Text();    tri(max_word,tri_police,tri_size);    QStringList cible;    for(int i=0; i < m_textCibles.size();i++)        cible << m_textCibles[i]->toString();    return cible;}

int main(){        int t = 285;    int p = 165;    int h = 143;    t++;    int tt = tri(t);    int pp = penta(p);    int hh = hexa(h);        while (1) {        if (tt == pp && tt == hh) {            break;        }                while (tt < pp && tt < hh) {            t++;            tt = tri(t);        }        while (pp < tt && pp < hh) {            p++;            pp = penta(p);        }        while (hh < tt && hh < pp) {            h++;            hh = hexa(h);        }    }        printf("tt: %d/n", tt);        return 0;}

int main(int argc, const char *argv[]) {    Shape *pshape;    Rectange rec(10, 7);    Triangle tri(10, 5);    // store the address of Rectangle    pshape = &rec;    // call rectangle area    pshape->area();    pshape = &tri;    pshape->area();    return 0;}

// Assemble lower-triangular matrix from log-diagonal and lower triangle and multiply by vector v// [ exp(q0)        0        0        0 ]// [      l0  exp(q2)        0        0 ]// [      l1       l2  exp(q3)        0 ]// [      l3       l4       l5  exp(q4) ]VectorD Qtimesv(VectorD const& q, Vector const& l, VectorD const& v){  VectorD ret(v.size());  for (size_t i = 0; i < size_t(v.size()); ++i) {    // let li = vectorSlice (Card i) (tri(i - 1)) l    // let vi = vectorSlice (Card i) 0 v    // vectorSum (li.*vi) + exp(q[i])*v[i]    size_t lstart = tri(i - 1);    double out = exp(q[i]) * v[i];    for (size_t k = 0; k < i; ++k)      out += l[lstart + k] * v[k];    ret[i] = out;  }  return ret;}

void TetrahedralMesh::computeFaceNormals(){	std::vector<Eigen::Vector3d> tri(3);	std::vector<Eigen::Vector3d> normals(4);	face_normals_.resize(tets_.size());	for(int i=0; i<(int)tets_.size(); i++){		for(int j=0; j<4; j++){			tri[0] = points_[tets_[i][faces[j][0]]];      tri[1] = points_[tets_[i][faces[j][1]]];      tri[2] = points_[tets_[i][faces[j][2]]];			      Eigen::Vector3d n = (tri[1]-tri[0]).cross(tri[2]-tri[0]);      n.normalize();      normals[j] = n;		}		face_normals_[i] = normals;	}}

		bool Mesh::MeshAdapter::intersect(int index, rt::core::Ray ray, rt::core::Intersection* result) const {			glm::vec2 uvs[3];			if (_uvs.size() == _points.size()) {				uvs[0] = _uvs[index * 3];				uvs[1] = _uvs[index * 3 + 1];				uvs[2] = _uvs[index * 3 + 2];			}			else{				uvs[0] = glm::vec2(0, 0);				uvs[1] = glm::vec2(1, 0);				uvs[2] = glm::vec2(0, 1);			}			Triangle tri(_points[index * 3], _points[index * 3 + 1], _points[index * 3 + 2],				uvs[0], uvs[1], uvs[2]);			return tri.intersect(ray, result);		}

Mesh::Mesh(std::string file, int start, float3 scale, float3 offset) : root() {	if (!fileExists(file + ".cobj")) {		std::ofstream outfile(file + ".cobj", std::ofstream::binary);		write(file + ".obj", outfile);		outfile.close();		shapes.clear();		materials.clear();	}	std::ifstream infile(file + ".cobj", std::ifstream::binary);	read(infile);	infile.close();	for (size_t i = 0; i < shapes.size(); i++) {		for (int f = 0; f < shapes[i].mesh.indices.size(); f += 3) {			int i1 = shapes[i].mesh.indices[f + 0];			float3 v0 = make_float3(shapes[i].mesh.positions[i1 * 3], shapes[i].mesh.positions[i1 * 3 + 1], shapes[i].mesh.positions[i1 * 3 + 2]) * scale + offset;			int i2 = shapes[i].mesh.indices[f + 1];			float3 v1 = make_float3(shapes[i].mesh.positions[i2 * 3], shapes[i].mesh.positions[i2 * 3 + 1], shapes[i].mesh.positions[i2 * 3 + 2]) * scale + offset;			int i3 = shapes[i].mesh.indices[f + 2];			float3 v2 = make_float3(shapes[i].mesh.positions[i3 * 3], shapes[i].mesh.positions[i3 * 3 + 1], shapes[i].mesh.positions[i3 * 3 + 2]) * scale + offset;			triBox triAABB(start + (int)aabbs.size(), fminf(fminf(v0, v1), v2), fmaxf(fmaxf(v0, v1), v2));			aabbs.push_back(triAABB);			//edge vectors			float3 vc1 = v1 - v0;			float3 vc2 = v2 - v1;			float3 vc3 = v0 - v2;			int materialID = shapes[i].mesh.material_ids[0];			float3 diffuse = make_float3(materials[materialID].diffuse[0], materials[materialID].diffuse[1], materials[materialID].diffuse[2]);			float3 emit = make_float3(materials[materialID].ambient[0], materials[materialID].ambient[1], materials[materialID].ambient[2]);			Triangle tri(make_float4(v0, 0), make_float4(v1, 0), make_float4(v2, 0), normalize(cross(vc1, vc2)), diffuse, emit);			triangles.push_back(tri);			root.minBounds = fminf(root.minBounds, fminf(fminf(v0, v1), v2));			root.maxBounds = fmaxf(root.maxBounds, fmaxf(fmaxf(v0, v1), v2));		}	}	//Cleanup	shapes.clear();	materials.clear();}

void tri(int height,int set_height){     int i;     if(height==1)     {         for(i=1;i<=set_height;i++)         {             printf("*");         }     }     else     {         tri(height-1,set_height);         printf("/n");         prchar(height,set_height);     }}

ogl_vertex_buffer geo_sphere::make_vertex_buffer(int res){	ogl_vertex_buffer ret;//	struct OGL_vert{		vector3d pos;	//	vector3d norm;//	};	int start = gs_sphere_start[res];	int ntri = n_tri(res);//	std::vector<OGL_vert> tri(ntri*3);	std::vector<vector3d> tri(ntri*3);	for(int i = 0; i<ntri; i++){		for(unsigned int v = 0; v<3; v++){			tri[i*3+v] = gspoints[gstris[start+i].point[v]];		//	tri[i*3+v].pos = gspoints[gstris[start+i].point[v]];		//	tri[i*3+v].norm = gspoints[gstris[start+i].point[v]];		}	}	ret.n_verts = (int)tri.size();//	ret.vertex_size = sizeof(OGL_vert);	ret.vertex_size = sizeof(vector3d);	ret.buffer = 0;//	ret.format = GL_N3F_V3F;	ret.format = GL_V3F;	if(tri.size() <1)return ret;//	glSetStrideSize(vertex_buffer[tid].vertex_size);	glGenBuffersARB(1, &ret.buffer);	ERROR_CHECK;	glBindBufferARB(GL_ARRAY_BUFFER_ARB, ret.buffer);	glBufferDataARB(GL_ARRAY_BUFFER_ARB, tri.size()*sizeof(vector3d),NULL, GL_STATIC_DRAW_ARB);	float*map = (float *)glMapBufferARB(GL_ARRAY_BUFFER_ARB, GL_WRITE_ONLY_ARB);	ERROR_CHECK;	memcpy(map, &tri[0], tri.size()*sizeof(vector3d)); 	glUnmapBufferARB(GL_ARRAY_BUFFER_ARB); 	glBindBufferARB(GL_ARRAY_BUFFER_ARB, 0);	return ret;}

// 对边iSeed--nnidx[start]找到下一个合适的顶点，形成三角形，并返回此顶点在nnidx中的序号int CPointMesh::formOneTriangle(size_t iSeed, size_t iPre, const ANNidx* nnidx, int start, int end, bool* bLinkedCenter){	size_t iCur = nnidx[start];	float* ptSeed = m_ps->getPoint(iSeed);	float* ptPre = m_ps->getPoint(iPre);	float* ptCur = m_ps->getPoint(iCur);	float eSeedPre[3] = Edge(ptSeed, ptPre);	float eSeedCur[3] = Edge(ptSeed, ptCur);	float ePreNorm[3];	eCross(ePreNorm, eSeedPre, eSeedCur);	// 前一个三角形的法矢	//===查找最合适的顶点扩展当前边iSeed-iCur===//	float maxFit = FLT_MINN;	int bestIdx = -1;	// 最优顶点的	for (int i = start+1; i< end+1; i++){		size_t iNext = nnidx[i];		POINTSTATUS ps = getPointStatus(iNext);		if ( ps == PS_INPOINT || ps == PS_BOUNDARY) continue;		float iNextFit = computeSeedPointFit(ptSeed, ptCur, iNext, ePreNorm);		if (iNextFit == FLT_MINN)	break;		if (iNextFit > maxFit){			maxFit = iNextFit;			bestIdx = i;		}	}	//===将找到的点形成三角形并更新连接信息===//	if (bestIdx != -1){// 找到合适顶点		bLinkedCenter[bestIdx] = true;		size_t iSelIndex = nnidx[bestIdx];	// 选择的顶点的序号		if(PS_UNUSED==m_links[ iSelIndex ].getStatus()){			m_links[ iSelIndex ].setStatus(PS_FRONTPOINT);			m_fontPoints.push_back(iSelIndex);		}		if (!m_links[ iSelIndex ].existLink(iSeed))	addLinkBtw(iSeed, iSelIndex);		if (!m_links[ iSelIndex ].existLink(iCur))		addLinkBtw(iCur, iSelIndex);		CTriangle tri(iSeed, iCur, iSelIndex);		tri.calcNorm(m_ps);		m_faces.push_back(tri);		return bestIdx;	}else{	// 未找到合适顶点，边界点		m_links[iSeed].setStatus(PS_BOUNDARY);		return start +1;	}}

RealclosestPtRayTriangle(Ray3 const & ray, Vector3 const & v0, Vector3 const & edge01, Vector3 const & edge02, Real & s,                     Vector3 & c1, Vector3 & c2){  Real sqdist = closestPtLineTriangle(Line3::fromPointAndDirection(ray.getOrigin(), ray.getDirection()), v0, edge01, edge02,                                      s, c1, c2);  if (s >= 0)    return sqdist;  // Not the most efficient way but the most convenient  LocalTriangle3 tri(v0, v0 + edge01, v0 + edge02);  s = 0;  c1 = ray.getOrigin();  c2 = tri.closestPoint(c1);  return (c1 - c2).squaredLength();}

voidgl_point_size (void){  char buf[BUFSIZ];  int i;  for (i = 1; i <= 4; i++)    {      snprintf (buf, BUFSIZ, "%f", (float) i);      test_prologue (buf);      glPointSize ((float) i);      tri ();      test_epilogue (true);    }  glPointSize (1.0);}

#include <kpathsea/config.h>#include "makejvf.h"#include <stdio.h>#include <math.h>int mquad(unsigned char *p){	unsigned int cc;	cc = (((unsigned int)p[0]*256		+(unsigned int)p[1])*256		+(unsigned int)p[2])*256		+(unsigned int)p[3];	return(cc);}#if 0 /* unused */unsigned int utri(unsigned char *p){	unsigned int i,cc;	unsigned char fchar[4];	fchar[0] = 0;	for (i = 1 ; i < 4 ; i++)		fchar[i] = p[i-1];	cc = mquad(fchar);	return cc;}#endif /* 0 */#if 0 /* unused */int tri(unsigned char *p){	int i,cc;	unsigned char fchar[4];	fchar[0] = 0;	for (i = 1 ; i < 4 ; i++)		fchar[i] = p[i-1];	cc = mquad(fchar);	if (cc > 8388607) cc -= 16777216;	return cc;}#endif /* 0 */unsigned int upair(unsigned char *p){	unsigned int i,cc;	unsigned char fchar[4];	fchar[0] = fchar[1] = 0;	for (i = 2 ; i < 4 ; i++)		fchar[i] = p[i-2];	cc = mquad(fchar);	return cc;}#if 0 /* unused */int pair(unsigned char *p){	int i,cc;	unsigned char fchar[4];	fchar[0] = fchar[1] = 0;	for (i = 2 ; i < 4 ; i++)		fchar[i] = p[i-2];	cc = mquad(fchar);	if (cc > 32767) cc -= 65536;	return cc;}#endif /* 0 */#if 0 /* unused */int mget(char *p, int num){	switch (num) {	case 1:		return *p;		break;	case 2:		return pair(p);		break;	case 3:		return tri(p);		break;	case 4:		return mquad(p);		break;	}}

main(){  double *A, *B, *C, *D, *XREF;  int    i, N, ind;  double  alpha = 5.0, V;  N = 4;  A = new double[N+1];  B = new double[N+1];  C = new double[N+1];  D = new double[N+1];  XREF = new double[N+1];    XREF[1] = 0.263158;   XREF[2] = 0.315789;   XREF[3] = 0.315789;   XREF[4] = 0.263158;   for (i=1; i<N+1; i++)  {     A[i] = -1;          // Lower off-diagonal     B[i] =  alpha;      // Diagonal //     B[i] =  0;     C[i] = -1;          // Upper off-diagonal     D[i] =  1;          // Right hand side  }  ind = 3;  // Factorize AND solve in one process  tri (ind, N, A, B, C, D, V);  if (ind==-1) printf("Division by zero in step one");  else  {    printf("Error is : /n /n");    for (i=1; i<N+1; i++)    {      printf("%f /n", fabs(D[i] - XREF[i]));    }    printf("/n V = %f /n", V);  }  return 0;}

int main(void){	int i, total = 0;	char word[15];	FILE *input = fopen("../input/42", "r");	fseek(input, 1, SEEK_SET);	while (fscanf(input, "%[^/"]", word) == 1) {		if (tri(value(word)))			++total;		fseek(input, 3, SEEK_CUR);	}	printf("%d/n", total);	fclose(input);	return 0;}