/*private*/ bool OffsetCurveSetBuilder::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 }; }
void QvisTurnDownButton::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 DirectedGraph::findAdjacentTriangle(int pIdx1, int pIdx2, int pIdx3) const { TriRecord tri(pIdx1, pIdx2, pIdx3); vector<shared_ptr<DAGNode>> triangles = DAGNode::leafNodesContainingEdge(root_, pointSet_, pIdx2, pIdx3); for (unsigned int i = 0; i < triangles.size(); i++) { /// "each triangle" int pIdx = tri.vertexNotSharedWith(triangles[i]->tri_); if (pIdx > 0) { return pIdx; } } return 0; // 0 is a 'bad index'; i.e. not found. }
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; } }
Real closestPtRayTriangle(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(); }
void gl_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; }