If no license key is found at runtime, a default evaluation license key is used which provides a free 30-day evaluation period for NMath on the current machine.

Three mechanisms are supported for setting your NMath license key:

• by setting the NMATH_LICENSE_KEY environment variable
• by setting the NMathLicenseKey configuration app setting
• by programmatically setting the LicenseKey property on class NMathConfiguration

Settings are applied in that order, and resetting the license key takes precedent over any earlier values. For example, here the environment variable is used:

 > set NMATH_LICENSE_KEY="<your key here>"

This code uses an app config file:

<?xml version="1.0" encoding="utf-8" ?>
<configuration>
  <appSettings>
    <add key="NMathLicenseKey" value="<your key here>" />
  </appSettings>
</configuration>

And this code accomplishes the same thing programmatically:

NMathConfiguration.LicenseKey = "<your key here>";

Note 1: Setting your license key works the same way for development and deployment machines.

Note 2: If you forget to set your license key on a machine, your code NMath code will work initially, using the default evaluation license, but this license will expire in 30 days.

The post Setting the NMath License Key appeared first on CenterSpace.

An NMath license file is no longer used.

NMath License Key

NMath license information is stored in a license key which must be found at runtime. The license key governs the properties of your NMath installation. If no license key is found, a default evaluation license key is used which provides a free 30-day evaluation period for NMath on the current machine.

When you purchase one or more developer seats of NMath, you will be issued a license key describing the terms of your license. To enter your license key:

1. Open CenterSpace Software | License NMath from your Start menu.
2. Enter your name, email, and license key, and click OK.

The license key will be written to the registry. You can also specify your license key using various other mechanisms: by environment variable, by configuration app setting, and programmatically. These mechanisms may be preferable in group development environments, and at deployment. (See below.)

NMath Configuration

NMath configuration settings govern the loading of the NMath license key, kernel assembly, and native library. Property values can be set three ways:

• by environment variable
• by configuration app setting
• by programmatically setting properties on class NMathConfiguration

Settings are applied in that order, and resetting a property takes precedent over any earlier values. For example, here an environment variable is used:

 > set NMATH_NATIVE_LOCATION="C:\tmp"

This code uses an app config file:

<?xml version="1.0" encoding="utf-8" ?>
<configuration>
  <appSettings>
    <add key="NMathNativeLocation" value="C:\tmp" />
  </appSettings>
</configuration>

And this code accomplishes the same thing programmatically:

NMathConfiguration.NativeLocation = @"C:\tmp";

Also, all paths can be specified relative to the executable. So to place the natives in an existing directory named resources adjacent to the executable one would
write:

NMathConfiguration.NativeLocation = @"..\resources";

The supported environment variables, configuration app setting keys, and property names are show below.

Environment Variable
Configuration Setting
Property


NMATH_LOG_LOCATION
NMathLogLocation
LogLocation


NMATH_LICENSE_KEY
NMathLicenseKey
LicenseKey


NMATH_NATIVE_LOCATION
NMathNativeLocation
NativeLocation


NMATH_USE_SEQUENTIAL_THREADING
NMathUseSequentialThreading
UseSequentialThreading


NMATH_USE_EXTERNAL_THREADING
NMathUseExternalThreading
UseExternalThreading

NOTE- Assembly loading and license checking is normally performed the first time you make an NMath call. If you wish to explicitly control when these operations occur–at application start-up, for example–use the static NMathConfiguration.Init() method.

For example, when using Mono on a Mac, to configured NMath with a sequentially threaded library set the environmental variable as follows.

 > export NMATH_USE_SEQUENTIAL_THREADING="True" 

Logging

To debug configuration issues, specify a log file location. For example, setting the property programmatically to place the NMath log file in the same directory as the executable one would write:

NMathConfiguration.LogLocation = @".";

Or if you prefer to use a global temporary directory you could specify an absolute path.

NMathConfiguration.LogLocation = @"C:\temp\logs";

This creates a file named NMathConfiguration.log at the specified location containing log output. The specified location must exist. To turn off logging, set the log location to null.

License Key

You can specify your NMath license key using the LicenseKey property, or the equivalent environment variable or app config setting. If so, any keys in the registry are ignored.

Native Location

The NMath native assembly must be found at runtime. Failure to locate this file is one of the most common configuration issues, especially in deployment. The search order is determined by your PATH (on Windows systems). Some standard locations are automatically prepended to your (process-specific) PATH. You can also use the NativeLocation property, or the equivalent environment variable or app config setting, to prepend another location.

Alternative Kernel and Native Assemblies

The names of the NMath kernel and native assemblies are determined by your platform (x86 or x64), and the values of the UseSequentialThreading and UseExternalThreading properties, as shown below:

Standard
     Kernel
          NMathKernelx86.dll
          NMathKernelx64.dll
     Native
          nmath_native_x86.dll
          nmath_native_x64.dll

Sequentially-Threaded
     Kernel
          NMathKernelx86Sequential.dll
          NMathKernelx64Sequential.dll
     Native
          nmath_native_x86_seq.dll
          nmath_native_x64_seq.dll

Externally-Threaded
     Kernel
          NMathKernelx86External.dll
          NMathKernelx64External.dll
     Native
          nmath_native_x86_ext.dll
          nmath_native_x64_ext.dll

Sequentially-threaded and externally-threaded kernel and native assemblies are available upon request from CenterSpace Software:

• Sequentially-Threaded: MKL contains highly optimized, extensively threaded math routines. In rare cases, these can cause conflicts between the Intel OMP threading library (libiomp.dll) and the .NET threading model. If your .NET application is itself highly multi-threaded, you may wish to use the sequentially-threaded version of MKL.
• Externally-Threaded: NMath normally statically links in the Intel OMP threading library described above. Sometimes this can cause collisions with libraries from other vendors that also use OMP. The externally-threaded version of NMath dynamically-links in OMP.

To trigger loading of these assemblies, use properties UseSequentialThreading and UseExternalThreading on class NMathConfiguration, or the equivalent environment variables or app config settings. Both properties default to false.

UseSequentialThreading and UseExternalThreading are mutually exclusive, and UseSequentialThreading takes precedence; UseExternalThreading only has an effect if UseSequentialThreading is false.

The post NMath Configuration appeared first on CenterSpace.

– Trevor

The post CenterSpace @ TechEd appeared first on CenterSpace.

There are a myriad of ways SQL Server can be setup and for this post, we took whatever shortcut we could find. Our goal was to get this running and worry about doing it “right” later. We found ourselves on a fairly steep learning curve without a lot of examples to work off of. Consider this more of a “proof of concept” post than the definitive “how to”.

As mentioned above there are lot of different approaches to this problem. In our minds, we wanted to see if we could couple our library at the server side and access results via Reporting Services and Report Builder. We believed that the computations would be more efficient to be handled at the server while the result could take advantage of the graphing packages in Report Services.

Our approach was to build a standalone system to develop and test this work on. We choose a standard PC platform running Windows 7. The first task at hand was to decide which version of Microsoft SQL Server to work with. We chose SQL Server 2008R2 full version as we needed the Report Services support. Microsoft supplies a six month trial version that has all services available which was perfect for our project. We installed the full version with support for the Management Studio, Report Services, and Analysis services. In addition, we downloaded Microsoft’s AdventureWorks sample databases for our testing environment.

We got this all running and ran some sample scripts to make sure we had everything running correctly before moving on. Since we were going to be developing code we installed Visual Studio 2010 next and made sure we included the necessary development templates for the SQL Server environment.

After installing CenterSpace’s NMath 5.0 library, we were ready to write some code.

We will start by creating a new project in Visual Studio called NMathSQL.

We then asked to pick a server and identify the database we will be using.

In the next screen we will want to enable SQL/CLR debugging.

At this point we need to start running SQL scripts as part of the overall setup. We could exit VS and perform these tasks in the Management Studio, but VS can do the job. By selecting from the VS menu bar Data>Transact-SQL Editor>New Query Connection, we get a new window to enter scripts to be run on our database.

We found it easier to copy and paste our scripts into this windows as we needed to run SQL statements.

Our first task at hand is to load the assembly NMath.dll into the database we have selected to work in. It is at this point we hit our first real obstacle. It turns out that in our shipping NMath.dll we are using some instructions to automatically load x86 or x64. These are illegal in the SQL CLR. We were forced to remove these instructions and build an entirely separate version of NMath.dll for SQL Server. Stepping back and looking at the big picture, we decided that this was an opportunity to also include some of the “glue” code we knew we wanted to write.

We had been looking at writing some User Defined Types (UDT) and User Defined Aggregate (UDA) functions to handle the calls into our library. It seemed to make sense to extend our libraries type definitions to be T-SQL types. The result of this approach would enable T-SQL to use NMath types such as DoubleVector and DoubleMatrix. We needed to have some way to load our new data types so we built UDAs LoadDoubleVector, LoadDoubleMatrixByRow, and LoadDoubleMatrixByColumn. After building our new, custom NMath.dll, we can then run a script to load our assembly into the database.

Before we could do this, though, we discovered that we needed some basic assemblies that SQL server had left out of their CLR. The following SQL script loads those assemblies.

We are now ready to run the following SQL script to load NMath for SQL.

The next step is to add the reference to our project. From the main toolbar launch the Solution Explorer and right click on Reference then select Add Reference. Add the new assemblies we have loaded so far.

We will now have to tell SQL about the new types and functions we have added. We will start by adding the new UDTs DoubleVector and DoubleMatrix.

Now that SQL knows about our new types we can add the UDA functions with the following SQL commands.

At this point we are ready to test our library. We have chosen a problem that represents the work expected to be perform. We will create our sample datapoint tables rather than use tables from the AdventureWorks database. We will then load the data from the tables into DoubleVectors and call our library using a User Defined Function(UDF). Our UDF will be a call to library to find the function values for a curve that fits our datapoints. From our function solution we will create a table with datapoints that represent our curve function to compare against our original datapoints.

We will start by creating the UDF call to our library. From the Solution Explorer, we will add a UDF template called NMathFunction.cs.

Here is the C# code for this function call:

using System;
using System.Data;
using System.Data.SqlClient;
using System.Data.SqlTypes;
using Microsoft.SqlServer.Server;
using CenterSpace.NMath.Core;
using CenterSpace.NMath.Analysis;


public partial class UserDefinedFunctions
{
    [Microsoft.SqlServer.Server.SqlFunction]
    public static DoubleVector NMathFunction(DoubleVector xValues, DoubleVector yValues, DoubleVector start)
    {
        NMathFunctions.GeneralizedDoubleUnaryFunction f = AnalysisFunctions.FourParameterLogistic;
        OneVariableFunctionFitter fitter = new OneVariableFunctionFitter(f);
        return new DoubleVector(fitter.Fit(xValues, yValues, start));
    }
}

We can now tell VS to build the assembly NmathSQL.dll and use SQL to load the assembly to our database.

In order for our UDF NmathFunction to be recognized we need to run a SQL create function command. Note that this command must be the only command in the script.

We have now loaded our NMath function call in the database that can be called by scripts. We are ready to write a script to solve the problem we described above.

We will start by using the same data from the example we did with our excel post.

We can now build a script that uses the functionality we have built in with our library to find the solution.

-------------------------------------------------------
Declare @xv DoubleVector
Declare @yv DoubleVector

select @xv = dbo.LoadDoubleVector(xcol) from xvalues
select @yv = dbo.LoadDoubleVector(ycol) from yvalues

Declare @sPar DoubleVector
Declare @solution DoubleVector

set @sPar = '[ 0.1 0.1 0.1 0.1]'

select @solution = dbo.NMathFunction(@xv, @yv, @sPar)
 
select @solution.ToString()

declare @newxval float
declare @newyval float
declare @inc float
declare @a float
declare @b float
declare @c float
declare @d float

set @a = dbo.DVItem(@solution, 0)
set @b = dbo.DVItem(@solution, 1)
set @c = dbo.DVItem(@solution, 2)
set @d = dbo.DVItem(@solution, 3)
 
create table SolutionTBL (newxval float, newyval float)
	set @newxval = 0
	 
	while @newxval < 35.10
	begin
	   
	    set @newyval = @d+((@a-@d)/(1+POWER((@newxval/@c), @b)))
			     
	    insert into SolutionTBL values(@newxval, @newyval)
	    
	  set @newxval = (@newxval + 0.33)
	end
	select * from SolutionTBL
	go
---------------------------------------------------------------------

Here is the output from this script

At this point we can pull data from tables, call our Math libraries, and put the solution in a table to be displayed. In production, this last script would be a stored procedure that would be run from the Management Studio. All of this work would reside on the SQL Server.

We can now move on to the Reporting Services to see how this solution could be displayed.

After launching Report Builder and establishing connection to the database. The data is accessed by setting up a dataset with a query into the table for the necessary data.

From there it is merely Report Builder to build the necessary graphs. Unfortunately, the chart wizard doesn't include scatterplots. It is best to select a chart type of Line and then run through the wizard. After your chart is set up you can change its properties to scatterplot.

We can include our solution in the same report and generate a smooth line as we did in excel. The Report Builder is a very powerful tool which we are still learning.

Our results are equivilent to our previous excel post and demonstrate that the approach on the SQL Server is as accurate.

In conclusion, we have demonstrated that we can call the CenterSpace NMath libraries from SQL Server and display the results using Report Services powerful charting capabilities. We plan to work on more examples and compare how we might improve on what Analysis Services can produce. We certainly will entertain feedback on useful approaches that should be examined. As a reminder this interface is not possible with our current release of NMath 5.0 and require a "special" version of our assembly. Depending on customer interest and feedback we may or may not decide to develop a product for this interface.

The post Accessing .Net Libraries in SQL Server appeared first on CenterSpace.

The post SuperComputing 2010 appeared first on CenterSpace.

NMath Student Editions are fully functional versions of the NMath libraries that expire in one year.  Perfect for the student taking .NET programming courses focusing on math, statistics or engineering.

“More and more students are requesting our libraries to help them with their programming projects.” says CEO Trevor Misfeldt  “This new edition allows them to use the NMath libraries for a longer period of time at a very low cost.”

This year you can go back to school with NMath!

Student versions are licensed for non-commerical use only, proof of student status is required after purchase and before delivery.

The post Go Back to School with NMath appeared first on CenterSpace.

Any one who would like to meet with them personally during their time in the Bay Area can contact Amy to schedule an appointment.  541.896.1301

The post Join CenterSpace at the Intel Developer Forum in San Francisco! appeared first on CenterSpace.

• professional high-speed data acquisition software
• real-time measurement and signal monitoring applications
• PC-based oscilloscopes and signal analyzers
• scientific research
• medical measurement displays
• topographic map rendering

Arction chose CenterSpace’s NMath tool set for driving their prototypical examples for the 2010 Measuring and Testing conference in Helsinki.

Package Offer

Our Arction and CenterSpace partnership offer is a bundle of the Arction LightningChart Ultimate and the NMath Suite for $3395.00 – that’s more than a 20% discount. That price includes a one-year subscription on all product extensions and upgrades. Both products are fully compatible with Visual Studio 2008 and 2010.

Arction’s LightningChart Pro

The LightningChart .NET \ C# chart tool is a complete and full featured real-time signal visualization tool. Here are a few of LightningChart’s key features.

• Different X-axis real-time monitoring scrolling modes: Scrolling, sweeping, stepping, oscilloscope style level triggered
• Smoothly renders huge amounts of measured data as graphs in real-time – up to hundreds of millions of new data points per second
• Full 64-bit support. Utilizes over 2 GB memory (in 64-bit systems).
• Various series types: SampleData, PointLines, FreeformLines, Bars, Bands, Constant lines
• Many Y axes/chart: stacked or layered
• Automatic scale fitting, grids and divisions
• Comprehensive user interface customization

For more information please visit the LightningChart product website.

Happy Computing,
Paul

The post NMath Driving New High Performance Signal Visualizer appeared first on CenterSpace.

” We were busting at the seams so it was time for a move.” said CenterSpace CEO Trevor Misfeldt  “Our team is growing so we can expand the functionality of the NMath software and provide more consulting services to our customers.”

Our new location is located on the third floor of the historic Crees Building in downtown Corvallis Oregon.

CenterSpace Software

230 SW 3rd Street, Suite #311

Corvallis OR, 97333

+1.541.896.1301

At the time of its construction in 1926, the Crees Building was the largest commercial building to ever be built in downtown Corvallis and it has played a major role in the commerce of the area.   Visitors can take a ride to our offices on the third floor in the oldest working (we hope!) elevator in Corvallis.

“With almost twice the square footage of our former location, we will not only be able to handle the growth of our staff but also provide a unique environment for our new series of quarterly training classes starting in August 2010.” says Misfeldt.

About CenterSpace Software
CenterSpace Software is a leading provider of enterprise class numerical component libraries for the .NET platform. Developers worldwide use CenterSpace products to develop .NET financial, engineering, and scientific applications. CenterSpace Software has offices in Corvallis, OR, and can be found on the Internet at https://www.centerspace.net.

The post We’ve Moved to a New Larger Location appeared first on CenterSpace.

Pure C#

Both libraries are now supported by a new pure C# math kernel doing away with our old C++ kernel. Because we are now a pure .NET assembly, deployment of NMath based applications is simplified by eliminating the Microsoft C++ runtime library dependency. As with all releases we will be posting our updated performance benchmarks at the time of the release.

Full Control

Additionally, our libraries have been re-architected to dynamically link to both native numerical libraries and ( and perhaps more importantly for our customers ) the Intel OMP threading library (libiomp.dll) . This means that our customers will have complete control over the threading library. In the past, we statically linked in OMP. Now, we are picking up OMP dynamically and thereby avoid collisions between statically and dynamically linked OMP libraries. In a nutshell, NMath will now play more nicely with libraries from other vendors.

New Features

Now for the fun stuff. The table below summarized the new features in NMath 4.1 and NMath Stats 3.2.

I hope you find these new additions to the library useful in your application work. If you are looking for something specific that isn’t currently supported in our library, please contact us. We build custom numeric classes for existing and new customers on a regular basis.

Happy Computing,
Paul

Update: In the final release, NMath still has a dependency on the Visual C++ 2008 runtime (msvcr90.dll)

The post July Release of NMath and NMath Stats appeared first on CenterSpace.