This file is indexed.

/usr/include/astro/attlib.h is in libastro-dev 4:4.13.0-0ubuntu1.

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
//
// This file is part of the Marble Virtual Globe.
//
// This program is free software licensed under the GNU LGPL. You can
// find a copy of this license in LICENSE.txt in the top directory of
// the source code.
//
// Copyright 2013 Gerhard Holtkamp
//

#if !defined(__attlib_h)
#define __attlib_h

/***********************************************************************
    3-Dim Vector and Matrix Definitions and Operations

  License: GNU LGPL Version 2+

  Author: Gerhard HOLTKAMP                   14-JAN-2012
 ***********************************************************************/

#include <iostream>
#include "astrolib_export.h"

ASTROLIB_EXPORT double atan20 (double y, double x);

class ASTROLIB_EXPORT Vec3
{
 private:
   double v[3];

 public:

   friend class Mat3;

   Vec3(double x=0, double y=0, double z=0);
   Vec3 (const Vec3& c);
   void assign (double x=0, double y=0, double z=0);
   double& operator [] (unsigned index);
   Vec3& operator = (const Vec3& c);
   Vec3& operator += (const Vec3& c);
   Vec3& operator -= (const Vec3& c);
   Vec3& operator *= (const Vec3& c);   // cross product
   Vec3& operator *= (double r);
   Vec3& operator /= (double r);
   friend double abs(const Vec3& c);               // absolute value
   friend double dot (const Vec3& c1, const Vec3& c2);   // dot product
   friend Vec3 operator + (const Vec3& c1, const Vec3& c2);
   friend Vec3 operator - (const Vec3& c1, const Vec3& c2);
   friend Vec3 operator * (double r, const Vec3& c1);
   friend Vec3 operator * (const Vec3& c1, double r);
   friend Vec3 operator * (const Vec3& c1, const Vec3& c2);  // cross product
   friend Vec3 operator / (const Vec3& c1, double r);
   friend Vec3 vnorm(const Vec3& c);       // norm vector
   friend Vec3 carpol (const Vec3& c);    // Cartesian -> Polar
   friend Vec3 polcar (const Vec3& c);    // Polar -> Cartesian
   friend std::ostream& operator << (std::ostream& os, const Vec3& c);
};

/********************************************************************/

// class Mat3: public Vec3
class ASTROLIB_EXPORT Mat3
{
 public:
   double m[3][3];

   Mat3(double x=0);
   Mat3 (const Mat3& c);
   void assign (double x11, double x12, double x13,  double x21, double x22,
                double x23, double x31, double x32, double x33);
   void assign (double x[3][3]);             // assign matrix
   void PutMij (double x, int i, int j);    // put single matrix element
   double GetMij (int i, int j) const;      // get single matrix element
   Mat3& operator = (const Mat3& c);
   Mat3& operator += (const Mat3& c);
   Mat3& operator -= (const Mat3& c);
   Mat3& operator *= (const Mat3& c);
   Mat3& operator *= (double r);
   Mat3& operator /= (double r);
   friend Mat3 mxtrn (const Mat3& m1);  // transposed matrix
   friend double mxdet (const Mat3& c); // determinant
   friend Mat3 operator + (const Mat3& c1, const Mat3& c2);
   friend Mat3 operator - (const Mat3& c1, const Mat3& c2);
   friend Mat3 operator * (double r, const Mat3& c1);
   friend Mat3 operator * (const Mat3& c1, double r);
   friend Mat3 operator * (const Mat3& c1, const Mat3& c2);
   friend Mat3 operator / (const Mat3& c1, double r);
   friend Vec3 mxvct (const Mat3& m1, Vec3& v1);  // multiply vector with matrix
   friend void gpyr (const Mat3& m1, double& p, double& y, double& r); // get p/y/r
   friend void mxevc (const Mat3& m, double& a, Vec3& v);  // eigenvector
   friend std::ostream& operator << (std::ostream& os, const Mat3& c);
};

//  ****************************************************************************
// defining the following functions here seems to make more compilers happy
   Mat3 mxcon (double r);  // constant matrix
   Mat3 mxidn ();          // identity matrix
	//  friend Mat3 mxtrn (const Mat3& m1);  // transposed matrix
   Mat3 xrot (double a);  // rotation around x-axis
   Mat3 yrot (double a);  // rotation around y-axis
   Mat3 zrot (double a);  // rotation around z-axis

   Mat3 csmx (double p, double y, double r); // pitch/yaw/roll matrix
   void vcpy (Vec3& v, double& p, double& y); // get pitch and yaw from vector
   void vcrp (Vec3& v, double& p, double& r); // get pitch and roll from vector
   Mat3 mxrox (double& a, Vec3& v);  // get matrix from eigenvector and angle

#endif         // __attlib_h sentry.