This file is indexed.

/usr/include/snlVector.h is in libsnl-dev 0.2.1.svn.18-1.

This file is owned by root:root, with mode 0o644.

The actual contents of the file can be viewed below.

  1
  2
  3
  4
  5
  6
  7
  8
  9
 10
 11
 12
 13
 14
 15
 16
 17
 18
 19
 20
 21
 22
 23
 24
 25
 26
 27
 28
 29
 30
 31
 32
 33
 34
 35
 36
 37
 38
 39
 40
 41
 42
 43
 44
 45
 46
 47
 48
 49
 50
 51
 52
 53
 54
 55
 56
 57
 58
 59
 60
 61
 62
 63
 64
 65
 66
 67
 68
 69
 70
 71
 72
 73
 74
 75
 76
 77
 78
 79
 80
 81
 82
 83
 84
 85
 86
 87
 88
 89
 90
 91
 92
 93
 94
 95
 96
 97
 98
 99
100
101
102
103
104
105
106
107
108
109
110
111
// libSNL - Simple Nurbs Library
// Copyright Scott A.E. Lanham, Australia.
// ---------------------------------------
// This program is free software; you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation; either version 2 of the License, or
// (at your option) any later version.
//
//  This program is distributed in the hope that it will be useful,
//  but WITHOUT ANY WARRANTY; without even the implied warranty of
//  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
//  GNU Library General Public License for more details.
//
//  You should have received a copy of the GNU Library General Public License
//  along with this program; if not, write to the Free Software
//  Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.

#ifndef SNLVECTOR_H
#define SNLVECTOR_H

class snlPoint;

#include "snlPoint.h"

#ifdef SGI_MIPS

    #include <iostream.h>
    #include <math.h>
    
#else

    #include <iostream>
    #include <cmath>
    
    using namespace std;
    
#endif

class snlVector
{
    public:

        snlVector();
        snlVector ( const snlPoint& pt1, const snlPoint& pt2, bool hmg = false );  // pt1 -> pt2. ( ie pt2 - pt1 ).
        snlVector ( snlPoint& pt, bool hmg = false );        
        snlVector ( double x, double y, double z, double w = 0.0, bool hmg = false );
        snlVector ( snlVector& v1, snlVector& v2 );

        void calc ( const snlPoint& pt1, const snlPoint& pt2 );
        
        void calcNormal ( snlPoint& pt1, snlPoint& pt2, snlPoint& pt3, snlPoint& pt4 );

        void crossProduct ( snlVector& v1, snlVector& v2 );
        
        double dot ( snlVector& vect );  // Dot product of two vectors.
        double dot ( snlPoint& pt );  // Treats point as vector.        

        double lengthSqrd();  // Length of vector squared.
        double length();  // Length of vector.
        void length ( double val );  // Set length of vector.
        
        double calcAbsCos ( snlVector& vect );  // Calculate absolute cosine of the angle between vectors.        
        double angle ( snlVector& vect );
        
        void unitise();  // Don't know if this is a real word. Turn vector into unit vector.

        double projectDist ( snlVector& fromVector );
        snlVector project ( snlVector& ontoVector );
        
        void projectXZ();  // Project onto the X-Z plane.        
        void projectXY();  // Project onto the X-Y plane.
        void projectYZ();  // Project onto the Y-Z plane.

        snlVector operator * ( double );  // Return vector multiplied by a scalar.
        snlVector operator + ( snlVector& vect );
        snlVector operator - ( snlVector& vect );
        
        void operator += ( snlVector& vect );
        void operator -= ( snlVector& vect );
        void operator *= ( double );  // Multiply this vector by a scalar.

        bool operator == ( snlVector& compare );

        double x();
        double y();
        double z();
        double w();
        
        void x ( double val );
        void y ( double val );
        void z ( double val );
        void w ( double val );
        
        void components ( double x, double y, double z, double w );
        void components ( double x, double y, double z );
        
        void components ( double* x, double* y, double* z, double* w );
        void components ( double* x, double* y, double* z );
        
        void zero();  // Zero the vector.
        
        bool isNull();

        void print();

        double  elements [ 4 ];
        
        bool    homogeneous;  // If true then is a 4-D vector.
};

#endif