Silverlight is a great way to build line of business applications, but at its core, Silverlight runs within a sandboxed environment, typically within a browser, and usually within a networked intranet or Internet environment.  NMath, on the other hand, uses native libraries to provide high-performance math capabilities to managed code.  While it’s possible to build a Silverlight application that calls NMath functions, it’s worth taking a step back to look at what you really want to accomplish with your software project.

Most often, we find that developers are tasked with building dashboard-style business applications that allow the user to initiate some sort of data analysis, and then see a visualization of results.  In these cases, we generally recommend:

1) Use Silverlight (or HTML5) on the client, perform the analysis on one or more servers, and expose web services to initiate the analysis and deliver the results.

This is probably the most favorable approach, and usually the architecture to default to unless there’s a compelling reason to the contrary.  Some of the advantages of this approach:

• It’s consistent with typical Silverlight application architecture; capabilities in Silverlight and ASP.NET make it easy to build this kind of application.
• It retains the deployment advantages of Silverlight: there’s no need to distribute and install native components to every client machine.
• It retains the cross-platform advantages of Silverlight: the application will work smoothly regardless of client hardware (including on Mac OS).
• Centralizing the analysis on a server makes it easier to scale up with improved server hardware and/or server farms.
• It makes efficient use of network bandwidth: usually there’s little need to transfer all of the source data between client and server, just the results of the analysis.

The primary disadvantages of this approach include:

• This might drive an architectural shift if it’s not already working in a client-server environment.
• It doesn’t take maximum advantage of available computing resources on the client, at least for the analysis (although the application can potentially use the client’s GPU for the visualization).

If you’re certain that you want to perform the analysis on the client using a Silverlight application, you can:

2) Use Silverlight 4+, and use COM interop to invoke COM components that were previously installed on the client.

3) Use Silverlight 5, and use Platform Invoke (P/Invoke) to invoke native components.

There are significant disadvantages to these approaches, in particular:

• You would need to separately distribute your components and get them preinstalled on the local machine.
• The client applications will only run on Windows; you cannot invoke native code on Mac OS from Silverlight.
• Users will need to explicitly grant elevated trust to the Silverlight application.
• You would also need to build your application with out of browser support (if you’re using COM interop).

For the COM interop approach you would use ComAutomationFactory.CreateObject() to instantiate dynamic COM objects, which would also mean that you would require C# 4, Silverlight 4, and Visual Studio 2010.  This approach is less than ideal for new applications; it’s primarily intended for interaction within controlled environments (e.g. interop with Microsoft Office).  For more about this, see:

• Silverlight and Desktop .NET Integration
• Cutting Edge Silverlight4 COM+ Features

For information about P/Invoke in Silverlight 5, see:

• How to: Call Unmanaged Code from Trusted Applications

However, if you’re certain that you want to build a rich client application to perform the analysis on Windows, then you should also evaluate whether Silverlight is the best choice for doing so.  Some alternatives include:

4) Create a rich client application using Windows Presentation Foundation, and run in within the browser using XBAP.

XBAP applications are WPF applications that run in partial trust inside a web browser.  You do have access to more local resources than you do in Silverlight, and you can request the user to grant additional trust if needed.  You’re restricted to using Internet Explorer and Firefox.  For more about this, see:

• WPF XAML Browser Applications Overview
• Wikipedia: XAML Browser Applications
• XBap.org

5) Create a rich client application using Windows Presentation Foundation or Windows Forms, and distribute it via ClickOnce Deployment.

In this scenario, you’re running a full client application within Windows, but taking advantage of some of the deployment advantages of the web, including initial distribution and facilities for automatic application updates.  Generally speaking, this is the preferred way to build rich client applications on Windows.  For more about ClickOnce, see:

• ClickOnce Security and Deployment
• Wikipedia: ClickOnce

Our experienced consulting team is available to help you work through the architectural options that would make the most sense for your specific application; just contact us at consulting@centerspace.net.

The post NMath and Silverlight appeared first on CenterSpace.

The following tests were performed on a DoubleVector of length 10,000,000.

1) Create a new vector. This isn’t really clearing out an existing vector but we thought we should include it for completeness.

 DoubleVector v2 = new DoubleVector( v.Length, 0.0 );

The big drawback here is that you’re creating new memory. Time: 419.5ms

2) Probably the first thing to come to mind is to simply iterate through the vector and set everything to zero.

for ( int i = 0; i < v.Length; i++ )
{
  v[i] = 0.0;
}

We have to do some checking in the index operator. No new memory is created. Time: 578.5ms

3) In some cases, you could iterate through the underlying array of data inside the DoubleVector.

 
for ( int i = 0; i < v.DataBlock.Data.Length; i++ )
{
  v.DataBlock.Data[i] = 0.0;
}

This is a little less intuitive. And, very importantly, it will not work with many views into other data structures. For example, a row slice of a matrix. However, it's easier for the CLR to optimize this loop. Time: 173.5ms

4) We can use the power of Intel's MKL to multiply the vector by zero.

 v.Scale( 0.0 );

Scale() does this in-place. No new memory is created. In this example, we assume that MKL has already been loaded and is ready to go which is true if another MKL-based NMath call was already made or if NMath was initialized. This method will work on all views of other data structures. Time: 170ms

5) This surprised us a bit but the best method we could find was to clear out the underlying array using Array.Clear() in .NET

 Array.Clear( v.DataBlock.Data, 0, v.DataBlock.Data.Length );

This creates no new memory. However, this will not work with non-contiguous views. However, this method is very fast. Time: 85.8ms

To make efficiently clearing a vector simpler for NMath users we have created a Clear() method and a Clear( Slice ) method on the vector and matrix classes. It will do the right thing in the right circumstance. It will be released in NMath 5.2 in 2012.

Test Code

using System;
using CenterSpace.NMath.Core;

namespace Test
{
  class ClearVector
  {
    static int size = 100000000;
    static int runs = 10;
    static int methods = 5;
    
    static void Main( string[] args )
    {
      System.Diagnostics.Stopwatch sw = new System.Diagnostics.Stopwatch();
      DoubleMatrix times = new DoubleMatrix( runs, methods );
      NMathKernel.Init();

      for ( int run = 0; run < runs; run++ )
      {
        Console.WriteLine( "Run {0}...", run );
        DoubleVector v = null;

        // Create a new one
        v = new DoubleVector( size, 1.0, 2.0 );
        sw.Start();
        DoubleVector v2 = new DoubleVector( v.Length, 0.0 );
        sw.Stop();
        times[run, 0] = sw.ElapsedMilliseconds;
        Console.WriteLine( Assert( v2 ) );

        // iterate through vector
        v = new DoubleVector( size, 1.0, 2.0 );
        sw.Reset();
        sw.Start();
        for ( int i = 0; i < v.Length; i++ )
        {
          v[i] = 0.0;
        }
        sw.Stop();
        times[run, 1] = sw.ElapsedMilliseconds;
        Console.WriteLine( Assert( v ) );

        // iterate through array
        v = new DoubleVector( size, 1.0, 2.0 );
        sw.Reset();
        sw.Start();
        for ( int i = 0; i < v.DataBlock.Data.Length; i++ )
        {
          v.DataBlock.Data[i] = 0.0;
        }
        sw.Stop();
        times[run, 2] = sw.ElapsedMilliseconds;
        Console.WriteLine( Assert( v ) );
        
        // scale
        v = new DoubleVector( size, 1.0, 2.0 );
        sw.Reset();
        sw.Start();
        v.Scale( 0.0 );
        sw.Stop();
        times[run, 3] = sw.ElapsedMilliseconds;
        Console.WriteLine( Assert( v ) );

        // Array Clear
        v = new DoubleVector( size, 1.0, 2.0 );
        sw.Reset();
        sw.Start();
        Array.Clear( v.DataBlock.Data, 0, v.DataBlock.Data.Length );
        sw.Stop();
        times[run, 4] = sw.ElapsedMilliseconds;
        Console.WriteLine( Assert( v ) );
        Console.WriteLine( times.Row( run ) );
      }
      Console.WriteLine( "Means: " + NMathFunctions.Mean( times ) );
    }

    private static bool Assert( DoubleVector v )
    {
      if ( v.Length != size )
      {
        return false;
      }
      for ( int i = 0; i < v.Length; ++i )
      {
        if ( v[i] != 0.0 )
        {
          return false;
        }
      }
      return true;
    }
  }
}

- Trevor

The post Clearing a vector appeared first on CenterSpace.

There is a one-time delay when the appropriate x86 or x64 native code is loaded. This cost can be easily controlled by the developer by using the NMathKernel.Init() method. Please see Initializing NMath for more details.

– Trevor

The post Initializing NMath appeared first on CenterSpace.

Two retired scientists, self-proclaimed duffers, came to us asking for help with their retirement project: to improve their putting using mathematics. Around the office at CenterSpace, we have been wondering if applying the fundamentals of math to the putting green might help us lower our scores this year. We sure could use some help! We will feature the results of their experiments in our quarterly newsletters throughout the year.

Armed with the NMath .NET math libraries they plan to attack the project in stages.

First, they will model the equations of motion in a simple way with the ball represented as a point, without the complications of the rotational dynamics of a real ball.

Second, they will develop a computer application to serve as a framework for solving the differential equations of motion and displaying this motion with 3d animations. For certain simple models of greens, this will allow the visualization of a putt given an initial direction and speed.

The next step will be to solve the two point boundary value problem: calculate the best initial direction and speed to get the ball into the cup at a reasonable speed. Also more complicated “real life” greens will be modeled, using least squares routines to fit known green elevation data.

“These greens are so fast I have to hold my putter over the ball and hit it with the shadow!” -Sam Snead

Finally, a more realistic model will be investigated to more precisely capture the rotational motion of a 42.67 mm ball on a grass surface.

Of course we have no illusions that this project will lower anyone’s handicap, because only hours on the golf course, the driving range and practice greens can do that. To our golfing scientist friends it’s a good excuse to both revisit the fun of their college math and physics and explore new and exciting golf courses throughout the world.

And… just maybe… seeing the ball drop in the hole on the computer will help them relieve the frustration of a morning on the real greens that we are all too familiar with!

“I would like to deny all allegations by Bob Hope that during my last game of golf, I hit an eagle, a birdie, an elk and a moose.” -Gerald Ford

Happy Retirement Guys!

Please check out some of the functionality the duffers used…

C# polynomial least squares
C# differential equations (Chapter 31). A lot more differential equation functionality is coming in June, 2011.

The post .NET Curve Fitting Applied to Golf appeared first on CenterSpace.

The post Configuring missing values appeared first on CenterSpace.