[Math.NET Numerics][1] is very nice, if it supports the operations you want.  The older Math.Net Iridium still supports more options.  Also, [dnAnalytics][2] is quite nice, but no longer being developed.  (It, as well as Iridium, are being merged into Math.NET Numerics.)

On the commercial side, there are some very good, robust options.  The [Extreme Optimization Numerical Libraries][3] work very well.  The [Visual Numerics][4] library also works very well (although with a royalty-based distribution...).


  [1]: http://numerics.mathdotnet.com/
  [2]: http://www.codeplex.com/dnAnalytics
  [3]: http://www.extremeoptimization.com/
  [4]: http://www.vni.com/products/imsl/

I believe that [Math.NET][1] has most of the features you mention. Yuu may want to look at it and see if it fits your needs.

You can take a look at the [Iridium samples][2] to see the syntax and example code.


  [1]: http://www.mathdotnet.com/
  [2]: http://mathnet.opensourcedotnet.info/doc/IridiumCodeSamples.ashx?HL=matrix

I have been using [ILNumerics][1] a lot. Also did some contributions to the project. It by know is the only library I know of, which does not spend half the CPU time in GC for [serious computations][2]. Its fast and mature. See the full [feature list][3]. 


  [1]: http://ilnumerics.net/
  [2]: http://ilnumerics.net/blog/fast-faster-performance-comparison-c-ilnumerics-fortran-matlab-and-numpy-part-ii
  [3]: http://ilnumerics.net/$FeatureList.html

In addition to the libraries mentioned in other posts I can say a few warm words about [FinMath][1] library. It is rather new library, but according to my experience it has several advantages. It is very easy to use this library. First, it has only one executable file (*.dll) for both 32-bit and 64-bit operating systems. Second, it is build on top of well-known Intel Math Kernel Library and therefore it provides very good performance. Managed .NET API provided by this library is also very extensive and flexible. But, it is proprietary software and costs considerable amount of money. It also lacks some functionality (e.g. compared to [NMath][2] from CenterSpace Software). Anyway, it worth time to try it.

  [1]: https://rtmath.net/products/finmath/
  [2]: http://www.centerspace.net/products/nmath/

I have two apps on the iTunes store - both implement push notifications.  While I was testing sending notifications to these production apps, I noticed that a push intended for app A was titled and opened app B.  

Both of these apps are installed on the same phone.  I looked in my device table and saw that the device Tokens (and of course, the Device ID) listed for the two apps were both the same.  

As required, I am using two different certificates on the server - one for each app.  I sort of assumed the device Token or certificate would route the message to the right app but clearly it isn&#39;t.

I can see in NSLog that the tokens being sent from each app are indeed the same. 

Should the device Token be unique to each app?  If so, any idea how my test phone could be sending the same device token for both apps to my server.  Keep in mind this is from two apps currently on the app store.  

Thanks for any help!


Is the APN Device Token unique to each individual app?

For a webapplication, when HTTPS is not available as a security measure, is it possible to still make the login somewhat secure? E.g.:

- Tokenize logins, to make repeat attacks difficult?
- Somehow encrypt the sent password from a HTML password field?

In particular I&#39;m using CakePHP and an AJAX POST call to trigger authentication (includes provided username and password).

Update on the problem:

 - HTTPS is not available. Period. If you don&#39;t like the the situation, consider it a theoretical question.
 - There are no explicit requirements, you have whatever HTTP, PHP and a browser (cookies, JavaScript etc.) offers in real life (no magic RSA binaries, PGP plugins).
 - Question is, what is the best, you can make out of *this* situation, that is better than sending the passwords plaintext. Knowing the drawbacks of each such solutions is a plus.
 - Any improvement better than plain passwords is welcome. We do not aim for a 100% l33tG0Dhx0r-proff solution. Difficult to crack is better than complicated to hack which is better than a trivial sniffing revealing the password.

Login without HTTPS, how to secure?

I need a C# library to deal with matrices. It should implement singular value decomposition, matrix inversion, etc

I&#39;ve used &lt;a href=&quot;http://www.codeproject.com/Articles/19032/C-Matrix-Library&quot;&gt;CSML&lt;/a&gt; before, but this does not implement some of the features i need. 

Some of the features are:  
Singular value decomposition  
Matrix inversion  
Trace  
Determinants  

**Suggested Libraries (from answers)**

(most of them implement the features stated above)

 - [Math .NET Numerics for .NET, Silverlight and Mono][1] (opensource)
 - [Extreme Optimization Numerical Libraries][2] (commercial, very
   complete)
 - [IL Numerics][3] (commercial)
 - [Deltix&#39;s FinMath numerical library][4] (commercial,  uses the Intel&#174;
   Math Kernel Library (MKL) and Intel&#174; Integrated Performance
   Primitives (IPP))
 - [Lightweight fast matrix class in C#][5] (Strassen algorithm, LU
   decomposition)

  [1]: http://numerics.mathdotnet.com/
  [2]: http://www.extremeoptimization.com/
  [3]: http://ilnumerics.net/$Home.html
  [4]: https://rtmath.net/products/finmath/
  [5]: http://blog.ivank.net/lightweight-matrix-class-in-c-strassen-algorithm-lu-decomposition.html

Recommendation for C# Matrix Library

I need a C# library to deal with matrices. It should implement singular value decomposition, matrix inversion, etc
I've used <a 19032="" href="<a href=" http:="" www.codeproject.com="" articles="" c-matrix-library&#x26;quot;&#x26;gt;csml&#x26;lt;="" a&#x22;="">http://www.codeproject.com/Articles/19032/C-Matrix-Library">CSML&#x3C;/a</a>> before, but this does not implement some of the features i need.
Some of the features are: 
Singular value decomposition 
Matrix inversion 
Trace 
Determinants
Suggested Libraries (from answers)
(most of them implement the features stated above)
<ul>
<li><a href="http://numerics.mathdotnet.com/" target="_blank" rel="noopener noreferrer">Math .NET Numerics for .NET, Silverlight and Mono</a> (opensource)</li>
<li><a href="http://www.extremeoptimization.com/" target="_blank" rel="noopener noreferrer">Extreme Optimization Numerical Libraries</a> (commercial, very
complete)</li>
<li><a href="http://ilnumerics.net/$Home.html" target="_blank" rel="noopener noreferrer">IL Numerics</a> (commercial)</li>
<li><a href="https://rtmath.net/products/finmath/" target="_blank" rel="noopener noreferrer">Deltix's FinMath numerical library</a> (commercial, uses the Intel®
Math Kernel Library (MKL) and Intel® Integrated Performance
Primitives (IPP))</li>
<li><a href="http://blog.ivank.net/lightweight-matrix-class-in-c-strassen-algorithm-lu-decomposition.html" target="_blank" rel="noopener noreferrer">Lightweight fast matrix class in C#</a> (Strassen algorithm, LU
decomposition)</li>
</ul>

**I&#39;m looking for the C# equivalent of Java&#39;s `final`. Does it exist?**

Does C# have anything like the following:

    public Foo(final int bar);

In the above example, `bar` is a read only variable and cannot be changed by `Foo()`. Is there any way to do this in C#?

For instance, maybe I have a long method that will be working with `x`, `y`, and `z` coordinates of some object (ints). I want to be absolutely certain that the function doesn&#39;t alter these values in any way, thereby corrupting the data. Thus, I would like to declare them readonly.

    public Foo(int x, int y, int z) {
         // do stuff
         x++; // oops. This corrupts the data. Can this be caught at compile time?
         // do more stuff, assuming x is still the original value.
    }

Can parameters be constant?

What if I have nested loops, and I want to break out of all of them at once?

    while (true) {
        // ...
        while (shouldCont) {
            // ...
            while (shouldGo) {
                // ...
                if (timeToStop) {
                    break; // Break out of everything?
                }
            }
        }
    }

In PHP, `break` takes an argument for the number of loops to break out of. Can something like this be done in C#?

What about something hideous, like `goto`?

    // In the innermost loop
    goto BREAK
    // ...
    BREAK: break; break; break;


How to break out of multiple loops at once in C#?

I&#39;m looking for a way with C# which I can serialize a class into XML and add a namespace, but define the prefix which that namespace will use.

Ultimately I&#39;m trying to generate the following XML:

&lt;!-- language: lang-xml --&gt;

    &lt;myNamespace:Node xmlns:myNamespace=&quot;...&quot;&gt;
      &lt;childNode&gt;something in here&lt;/childNode&gt;
    &lt;/myNamespace:Node&gt;

I know with both the `DataContractSerializer` and the `XmlSerializer` I can add a namespace, but they seem to generate a prefix internally, with something that I&#39;m not able to control. Am I able to control it with either of these serializers (I can use either of them)?

If I&#39;m not able to control the generation of the namespaces will I need to write my own XML serializer, and if so, what&#39;s the best one to write it for?

XML Serialization and namespace prefixes

I have this code :

    /*string theXml =
    @&quot;&lt;Response xmlns=&quot;&quot;http://myvalue.com&quot;&quot;&gt;&lt;Result xmlns:a=&quot;&quot;http://schemas.datacontract.org/2004/07/My.Namespace&quot;&quot; xmlns:i=&quot;&quot;http://www.w3.org/2001/XMLSchema-instance&quot;&quot;&gt;&lt;a:TheBool&gt;true&lt;/a:TheBool&gt;&lt;a:TheId&gt;1&lt;/a:TheId&gt;&lt;/Result&gt;&lt;/Response&gt;&quot;;*/

    string theXml = @&quot;&lt;Response&gt;&lt;Result&gt;&lt;TheBool&gt;true&lt;/TheBool&gt;&lt;TheId&gt;1&lt;/TheId&gt;&lt;/Result&gt;&lt;/Response&gt;&quot;;

    XDocument xmlElements = XDocument.Parse(theXml);

    var elements = from data in xmlElements.Descendants(&quot;Result&quot;)
                   select new {
                                TheBool = (bool)data.Element(&quot;TheBool&quot;),
                                TheId = (int)data.Element(&quot;TheId&quot;),
                              };

    foreach (var element in elements)
    {
        Console.WriteLine(element.TheBool);
        Console.WriteLine(element.TheId);
    }

When I use the first value for theXml, the result is null, whereas with the second one, I have good values ...

How to use Linq to Xml with xmlns values ?



Use Linq to Xml with Xml namespaces

How can we use global.asax in asp.net? And what is that?

What is the purpose of global.asax in asp.net

So, I&#39;m doing some Kmeans classification using numpy arrays that are quite sparse-- lots and lots of zeroes.  I figured that I&#39;d use scipy&#39;s &#39;sparse&#39; package to reduce the storage overhead, but I&#39;m a little confused about how to create arrays, not matrices.

I&#39;ve gone through this tutorial on how to create sparse matrices:
http://www.scipy.org/SciPy_Tutorial#head-c60163f2fd2bab79edd94be43682414f18b90df7

To mimic an array, I just create a 1xN matrix, but as you may guess, Asp.dot(Bsp) doesn&#39;t quite work because you can&#39;t multiply two 1xN matrices.  I&#39;d have to transpose each array to  Nx1, and that&#39;s pretty lame, since I&#39;d be doing it for every dot-product calculation.

Next up, I tried to create an NxN matrix where column 1 == row 1 (such that you can multiply two matrices and just take the top-left corner as the dot product), but that turned out to be really inefficient.

I&#39;d love to use scipy&#39;s sparse package as a magic replacement for numpy&#39;s array(), but as yet, I&#39;m not really sure what to do.

Any advice?

Scipy sparse... arrays?

Is there a smart and space-efficient symmetric matrix in numpy which automatically (and transparently) fills the position at `[j][i]` when `[i][j]` is written to?

    import numpy
    a = numpy.symmetric((3, 3))
    a[0][1] = 1
    a[1][0] == a[0][1]
    # True
    print(a)
    # [[0 1 0], [1 0 0], [0 0 0]]
    
    assert numpy.all(a == a.T) # for any symmetric matrix

An automatic Hermitian would also be nice, although I won’t need that at the time of writing.



Numpy ‘smart’ symmetric matrix

Suppose I have the following matrix:

    01 02 03 06
    03 05 07 02
    13 10 11 12
    32 01 08 03

And I want the indices of the top 5 elements (in this case, 32, 13, 12, 11, 10). What is the cleanest way to do this in MATLAB?


Get the indices of the n largest elements in a matrix

Does anyone know how to count the number of times a value appears in a matrix?

For example, if I have a 1500 x 1 matrix `M` (vector) which stores the values of weekdays (1 - 7), how could I count how many Sundays (1), Mondays(2), ... , Saturdays(7) are stored in `M`?

How can I count the number of elements of a given value in a matrix?

**( edit: I added the best working approach in my [augmented reality framework][1] and now also take the gyroscope into account which makes it much more stable again: [DroidAR framework][1] )**

I have written a TestSuite to find out how to calculate the rotation angles from the data you get in `SensorEventListener.onSensorChanged()`.
I really hope you can complete my solution to help people who will have the same problems like me. Here is the code, I think you will understand it after reading it.

Feel free to change it, the main idea was to implement several methods to send the orientation angles to the opengl view or any other target which would need it.

method 1 to 4 are working, they are directly sending the rotationMatrix to the OpenGl view.

method 6 works now too, but I have no explanation why the rotation has to be done y x z..

all other methods are not working or buggy and I hope someone knows to get them working.I think the best method would be method 5 if it would work, because it would be the easiest to understand but i&#39;m not sure how efficient it is. the complete code isn&#39;t optimized so I recommend to not use it as it is in your project.

here it is:
    
    
    /**
     * This class provides a basic demonstration of how to use the
     * {@link android.hardware.SensorManager SensorManager} API to draw a 3D
     * compass.
     */
    public class SensorToOpenGlTests extends Activity implements Renderer,
      SensorEventListener {
    
     private static final boolean TRY_TRANSPOSED_VERSION = false;
    
     /*
      * MODUS overview:
      * 
      * 1 - unbufferd data directly transfaired from the rotation matrix to the
      * modelview matrix
      * 
      * 2 - buffered version of 1 where both acceleration and magnetometer are
      * buffered
      * 
      * 3 - buffered version of 1 where only magnetometer is buffered
      * 
      * 4 - buffered version of 1 where only acceleration is buffered
      * 
      * 5 - uses the orientation sensor and sets the angles how to rotate the
      * camera with glrotate()
      * 
      * 6 - uses the rotation matrix to calculate the angles
      * 
      * 7 to 12 - every possibility how the rotationMatrix could be constructed
      * in SensorManager.getRotationMatrix (see
      * http://www.songho.ca/opengl/gl_anglestoaxes.html#anglestoaxes for all
      * possibilities)
      */
    
     private static int MODUS = 2;
    
     private GLSurfaceView openglView;
     private FloatBuffer vertexBuffer;
     private ByteBuffer indexBuffer;
     private FloatBuffer colorBuffer;
    
     private SensorManager mSensorManager;
     private float[] rotationMatrix = new float[16];
     private float[] accelGData = new float[3];
     private float[] bufferedAccelGData = new float[3];
     private float[] magnetData = new float[3];
     private float[] bufferedMagnetData = new float[3];
     private float[] orientationData = new float[3];
    
     // private float[] mI = new float[16];
    
     private float[] resultingAngles = new float[3];
    
     private int mCount;
    
     final static float rad2deg = (float) (180.0f / Math.PI);
    
     private boolean landscape;
    
     public SensorToOpenGlTests() {
     }
    
     /** Called with the activity is first created. */
     @Override
     public void onCreate(Bundle savedInstanceState) {
      super.onCreate(savedInstanceState);
    
      mSensorManager = (SensorManager) getSystemService(Context.SENSOR_SERVICE);
      openglView = new GLSurfaceView(this);
      openglView.setRenderer(this);
      setContentView(openglView);
     }
    
     @Override
     protected void onResume() {
      // Ideally a game should implement onResume() and onPause()
      // to take appropriate action when the activity looses focus
      super.onResume();
      openglView.onResume();
    
      if (((WindowManager) getSystemService(WINDOW_SERVICE))
        .getDefaultDisplay().getOrientation() == 1) {
       landscape = true;
      } else {
       landscape = false;
      }
    
      mSensorManager.registerListener(this, mSensorManager
        .getDefaultSensor(Sensor.TYPE_ACCELEROMETER),
        SensorManager.SENSOR_DELAY_GAME);
      mSensorManager.registerListener(this, mSensorManager
        .getDefaultSensor(Sensor.TYPE_MAGNETIC_FIELD),
        SensorManager.SENSOR_DELAY_GAME);
      mSensorManager.registerListener(this, mSensorManager
        .getDefaultSensor(Sensor.TYPE_ORIENTATION),
        SensorManager.SENSOR_DELAY_GAME);
     }
    
     @Override
     protected void onPause() {
      // Ideally a game should implement onResume() and onPause()
      // to take appropriate action when the activity looses focus
      super.onPause();
      openglView.onPause();
      mSensorManager.unregisterListener(this);
     }
    
     public int[] getConfigSpec() {
      // We want a depth buffer, don&#39;t care about the
      // details of the color buffer.
      int[] configSpec = { EGL10.EGL_DEPTH_SIZE, 16, EGL10.EGL_NONE };
      return configSpec;
     }
    
     public void onDrawFrame(GL10 gl) {
    
      // clear screen and color buffer:
      gl.glClear(GL10.GL_COLOR_BUFFER_BIT | GL10.GL_DEPTH_BUFFER_BIT);
      // set target matrix to modelview matrix:
      gl.glMatrixMode(GL10.GL_MODELVIEW);
      // init modelview matrix:
      gl.glLoadIdentity();
      // move camera away a little bit:
    
      if ((MODUS == 1) || (MODUS == 2) || (MODUS == 3) || (MODUS == 4)) {
    
       if (landscape) {
        // in landscape mode first remap the rotationMatrix before using
        // it with glMultMatrixf:
        float[] result = new float[16];
        SensorManager.remapCoordinateSystem(rotationMatrix,
          SensorManager.AXIS_Y, SensorManager.AXIS_MINUS_X,
          result);
        gl.glMultMatrixf(result, 0);
       } else {
        gl.glMultMatrixf(rotationMatrix, 0);
       }
      } else {
       //in all other modes do the rotation by hand
       //the order y x z is important!
       gl.glRotatef(resultingAngles[2], 0, 1, 0);
       gl.glRotatef(resultingAngles[1], 1, 0, 0);
       gl.glRotatef(resultingAngles[0], 0, 0, 1);
      }
      
      //move the axis to simulate augmented behaviour:
      gl.glTranslatef(0, 2, 0);
      
      // draw the 3 axis on the screen:
      gl.glVertexPointer(3, GL_FLOAT, 0, vertexBuffer);
      gl.glColorPointer(4, GL_FLOAT, 0, colorBuffer);
      gl.glDrawElements(GL_LINES, 6, GL_UNSIGNED_BYTE, indexBuffer);
     }
    
     public void onSurfaceChanged(GL10 gl, int width, int height) {
      gl.glViewport(0, 0, width, height);
      float r = (float) width / height;
      gl.glMatrixMode(GL10.GL_PROJECTION);
      gl.glLoadIdentity();
      gl.glFrustumf(-r, r, -1, 1, 1, 10);
     }
    
     public void onSurfaceCreated(GL10 gl, EGLConfig config) {
      gl.glDisable(GL10.GL_DITHER);
      gl.glClearColor(1, 1, 1, 1);
      gl.glEnable(GL10.GL_CULL_FACE);
      gl.glShadeModel(GL10.GL_SMOOTH);
      gl.glEnable(GL10.GL_DEPTH_TEST);
    
      gl.glEnableClientState(GL10.GL_VERTEX_ARRAY);
      gl.glEnableClientState(GL10.GL_COLOR_ARRAY);
    
      // load the 3 axis and there colors:
      float vertices[] = { 0, 0, 0, 1, 0, 0, 0, 1, 0, 0, 0, 1 };
      float colors[] = { 0, 0, 0, 0, 1, 0, 0, 1, 0, 1, 0, 1, 0, 0, 1, 1 };
      byte indices[] = { 0, 1, 0, 2, 0, 3 };
    
      ByteBuffer vbb;
      vbb = ByteBuffer.allocateDirect(vertices.length * 4);
      vbb.order(ByteOrder.nativeOrder());
      vertexBuffer = vbb.asFloatBuffer();
      vertexBuffer.put(vertices);
      vertexBuffer.position(0);
    
      vbb = ByteBuffer.allocateDirect(colors.length * 4);
      vbb.order(ByteOrder.nativeOrder());
      colorBuffer = vbb.asFloatBuffer();
      colorBuffer.put(colors);
      colorBuffer.position(0);
    
      indexBuffer = ByteBuffer.allocateDirect(indices.length);
      indexBuffer.put(indices);
      indexBuffer.position(0);
     }
    
     public void onAccuracyChanged(Sensor sensor, int accuracy) {
     }
    
     public void onSensorChanged(SensorEvent event) {
    
      // load the new values:
      loadNewSensorData(event);
    
      if (MODUS == 1) {
       SensorManager.getRotationMatrix(rotationMatrix, null, accelGData,
         magnetData);
      }
    
      if (MODUS == 2) {
       rootMeanSquareBuffer(bufferedAccelGData, accelGData);
       rootMeanSquareBuffer(bufferedMagnetData, magnetData);
       SensorManager.getRotationMatrix(rotationMatrix, null,
         bufferedAccelGData, bufferedMagnetData);
      }
    
      if (MODUS == 3) {
       rootMeanSquareBuffer(bufferedMagnetData, magnetData);
       SensorManager.getRotationMatrix(rotationMatrix, null, accelGData,
         bufferedMagnetData);
      }
    
      if (MODUS == 4) {
       rootMeanSquareBuffer(bufferedAccelGData, accelGData);
       SensorManager.getRotationMatrix(rotationMatrix, null,
         bufferedAccelGData, magnetData);
      }
    
      if (MODUS == 5) {
       // this mode uses the sensor data recieved from the orientation
       // sensor
       resultingAngles = orientationData.clone();
       if ((-90 &gt; resultingAngles[1]) || (resultingAngles[1] &gt; 90)) {
        resultingAngles[1] = orientationData[0];
        resultingAngles[2] = orientationData[1];
        resultingAngles[0] = orientationData[2];
       }
      }
    
      if (MODUS == 6) {
       SensorManager.getRotationMatrix(rotationMatrix, null, accelGData,
         magnetData);
       final float[] anglesInRadians = new float[3];
       SensorManager.getOrientation(rotationMatrix, anglesInRadians);
       //TODO check for landscape mode
       resultingAngles[0] = anglesInRadians[0] * rad2deg;
       resultingAngles[1] = anglesInRadians[1] * rad2deg;
       resultingAngles[2] = anglesInRadians[2] * -rad2deg;
      }
    
      if (MODUS == 7) {
       SensorManager.getRotationMatrix(rotationMatrix, null, accelGData,
         magnetData);
    
       rotationMatrix = transpose(rotationMatrix);
       /*
        * this assumes that the rotation matrices are multiplied in x y z
        * order Rx*Ry*Rz
        */
    
       resultingAngles[2] = (float) (Math.asin(rotationMatrix[2]));
       final float cosB = (float) Math.cos(resultingAngles[2]);
       resultingAngles[2] = resultingAngles[2] * rad2deg;
       resultingAngles[0] = -(float) (Math.acos(rotationMatrix[0] / cosB))
         * rad2deg;
       resultingAngles[1] = (float) (Math.acos(rotationMatrix[10] / cosB))
         * rad2deg;
      }
    
      if (MODUS == 8) {
       SensorManager.getRotationMatrix(rotationMatrix, null, accelGData,
         magnetData);
       rotationMatrix = transpose(rotationMatrix);
       /*
        * this assumes that the rotation matrices are multiplied in z y x
        */
    
       resultingAngles[2] = (float) (Math.asin(-rotationMatrix[8]));
       final float cosB = (float) Math.cos(resultingAngles[2]);
       resultingAngles[2] = resultingAngles[2] * rad2deg;
       resultingAngles[1] = (float) (Math.acos(rotationMatrix[9] / cosB))
         * rad2deg;
       resultingAngles[0] = (float) (Math.asin(rotationMatrix[4] / cosB))
         * rad2deg;
      }
    
      if (MODUS == 9) {
       SensorManager.getRotationMatrix(rotationMatrix, null, accelGData,
         magnetData);
       rotationMatrix = transpose(rotationMatrix);
       /*
        * this assumes that the rotation matrices are multiplied in z x y
        * 
        * note z axis looks good at this one
        */
    
       resultingAngles[1] = (float) (Math.asin(rotationMatrix[9]));
       final float minusCosA = -(float) Math.cos(resultingAngles[1]);
       resultingAngles[1] = resultingAngles[1] * rad2deg;
       resultingAngles[2] = (float) (Math.asin(rotationMatrix[8]
         / minusCosA))
         * rad2deg;
       resultingAngles[0] = (float) (Math.asin(rotationMatrix[1]
         / minusCosA))
         * rad2deg;
      }
    
      if (MODUS == 10) {
       SensorManager.getRotationMatrix(rotationMatrix, null, accelGData,
         magnetData);
       rotationMatrix = transpose(rotationMatrix);
       /*
        * this assumes that the rotation matrices are multiplied in y x z
        */
    
       resultingAngles[1] = (float) (Math.asin(-rotationMatrix[6]));
       final float cosA = (float) Math.cos(resultingAngles[1]);
       resultingAngles[1] = resultingAngles[1] * rad2deg;
       resultingAngles[2] = (float) (Math.asin(rotationMatrix[2] / cosA))
         * rad2deg;
       resultingAngles[0] = (float) (Math.acos(rotationMatrix[5] / cosA))
         * rad2deg;
      }
    
      if (MODUS == 11) {
       SensorManager.getRotationMatrix(rotationMatrix, null, accelGData,
         magnetData);
       rotationMatrix = transpose(rotationMatrix);
       /*
        * this assumes that the rotation matrices are multiplied in y z x
        */
    
       resultingAngles[0] = (float) (Math.asin(rotationMatrix[4]));
       final float cosC = (float) Math.cos(resultingAngles[0]);
       resultingAngles[0] = resultingAngles[0] * rad2deg;
       resultingAngles[2] = (float) (Math.acos(rotationMatrix[0] / cosC))
         * rad2deg;
       resultingAngles[1] = (float) (Math.acos(rotationMatrix[5] / cosC))
         * rad2deg;
      }
    
      if (MODUS == 12) {
       SensorManager.getRotationMatrix(rotationMatrix, null, accelGData,
         magnetData);
       rotationMatrix = transpose(rotationMatrix);
       /*
        * this assumes that the rotation matrices are multiplied in x z y
        */
    
       resultingAngles[0] = (float) (Math.asin(-rotationMatrix[1]));
       final float cosC = (float) Math.cos(resultingAngles[0]);
       resultingAngles[0] = resultingAngles[0] * rad2deg;
       resultingAngles[2] = (float) (Math.acos(rotationMatrix[0] / cosC))
         * rad2deg;
       resultingAngles[1] = (float) (Math.acos(rotationMatrix[5] / cosC))
         * rad2deg;
      }
      logOutput();
     }
    
     /**
      * transposes the matrix because it was transposted (inverted, but here its
      * the same, because its a rotation matrix) to be used for opengl
      * 
      * @param source
      * @return
      */
     private float[] transpose(float[] source) {
      final float[] result = source.clone();
      if (TRY_TRANSPOSED_VERSION) {
       result[1] = source[4];
       result[2] = source[8];
       result[4] = source[1];
       result[6] = source[9];
       result[8] = source[2];
       result[9] = source[6];
      }
      // the other values in the matrix are not relevant for rotations
      return result;
     }
    
     private void rootMeanSquareBuffer(float[] target, float[] values) {
    
      final float amplification = 200.0f;
      float buffer = 20.0f;
    
      target[0] += amplification;
      target[1] += amplification;
      target[2] += amplification;
      values[0] += amplification;
      values[1] += amplification;
      values[2] += amplification;
    
      target[0] = (float) (Math
        .sqrt((target[0] * target[0] * buffer + values[0] * values[0])
          / (1 + buffer)));
      target[1] = (float) (Math
        .sqrt((target[1] * target[1] * buffer + values[1] * values[1])
          / (1 + buffer)));
      target[2] = (float) (Math
        .sqrt((target[2] * target[2] * buffer + values[2] * values[2])
          / (1 + buffer)));
    
      target[0] -= amplification;
      target[1] -= amplification;
      target[2] -= amplification;
      values[0] -= amplification;
      values[1] -= amplification;
      values[2] -= amplification;
     }
    
     private void loadNewSensorData(SensorEvent event) {
      final int type = event.sensor.getType();
      if (type == Sensor.TYPE_ACCELEROMETER) {
       accelGData = event.values.clone();
      }
      if (type == Sensor.TYPE_MAGNETIC_FIELD) {
       magnetData = event.values.clone();
      }
      if (type == Sensor.TYPE_ORIENTATION) {
       orientationData = event.values.clone();
      }
     }
    
     private void logOutput() {
      if (mCount++ &gt; 30) {
       mCount = 0;
       Log.d(&quot;Compass&quot;, &quot;yaw0: &quot; + (int) (resultingAngles[0])
         + &quot;  pitch1: &quot; + (int) (resultingAngles[1]) + &quot;  roll2: &quot;
         + (int) (resultingAngles[2]));
      }
     }
    }


  [1]: https://github.com/bitstars/droidar

Content Type	Original Author	Original Content on Stackoverflow
Question	jose	View Question on Stackoverflow
Solution 1 - C#	Reed Copsey	View Answer on Stackoverflow
Solution 2 - C#	LBushkin	View Answer on Stackoverflow
Solution 3 - C#	user492238	View Answer on Stackoverflow
Solution 4 - C#	vharavy	View Answer on Stackoverflow

Recommendation for C# Matrix Library

C# Problem Overview

C# Solutions

Solution 1 - C#

Solution 2 - C#

Solution 3 - C#

Solution 4 - C#

Login without HTTPS, how to secure?

Is the APN Device Token unique to each individual app?

Attributions