/*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;
}
