/*
* MATLAB Compiler: 4.14 (R2010b)
* Date: Wed Feb 01 09:59:21 2012
* Arguments: "-B" "macro_default" "-W"
* "dotnet:BwnFunctions,BwnFunctions,3.5,f:\OpenEarthTools\websites\dataviewer\dotnet\BwnFu
* nctions2DotNET\Interpolate.snk" "-T" "link:lib" "-d"
* "f:\OpenEarthTools\websites\dataviewer\dotnet\BwnFunctions2DotNET\BwnFunctions\src"
* "-N" "-w" "enable:specified_file_mismatch" "-w" "enable:repeated_file" "-w"
* "enable:switch_ignored" "-w" "enable:missing_lib_sentinel" "-w" "enable:demo_license"
* "-v"
* "class{BwnFunctions:f:\OpenEarthTools\websites\dataviewer\dotnet\BwnFunctions2DotNET\Ini
* tialize.m,F:\OpenEarthTools\websites\dataviewer\wrapperfunctions\InterpolateToLine.m,F:\
* OpenEarthTools\websites\dataviewer\wrapperfunctions\PlotTimeSeries.m,F:\OpenEarthTools\w
* ebsites\dataviewer\wrapperfunctions\WaveTransformationTable.m}" "-a"
* "F:\OpenEarthTools\src\matlab\applications\SuperTrans\data\EPSG.mat" "-a"
* "F:\OpenEarthTools\websites\dataviewer\tools\Tool_Anton\TransMatrix_InputParameters.mat"
*/
using System;
using System.Reflection;
using System.IO;
using MathWorks.MATLAB.NET.Arrays;
using MathWorks.MATLAB.NET.Utility;

#if SHARED
[assembly: System.Reflection.AssemblyKeyFile(@"f:\OpenEarthTools\websites\dataviewer\dotnet\BwnFunctions2DotNET\Interpolate.snk")]
#endif

namespace BwnFunctionsNative
{
  /// <summary>
  /// The BwnFunctions class provides a CLS compliant, Object (native) interface to the
  /// M-functions contained in the files:
  /// <newpara></newpara>
  /// f:\OpenEarthTools\websites\dataviewer\dotnet\BwnFunctions2DotNET\Initialize.m
  /// <newpara></newpara>
  /// F:\OpenEarthTools\websites\dataviewer\wrapperfunctions\InterpolateToLine.m
  /// <newpara></newpara>
  /// F:\OpenEarthTools\websites\dataviewer\wrapperfunctions\PlotTimeSeries.m
  /// <newpara></newpara>
  /// F:\OpenEarthTools\websites\dataviewer\wrapperfunctions\WaveTransformationTable.m
  /// <newpara></newpara>
  /// deployprint.m
  /// <newpara></newpara>
  /// printdlg.m
  /// </summary>
  /// <remarks>
  /// @Version 3.5
  /// </remarks>
  public class BwnFunctions : IDisposable
  {
    #region Constructors

    /// <summary internal= "true">
    /// The static constructor instantiates and initializes the MATLAB Compiler Runtime
    /// instance.
    /// </summary>
    static BwnFunctions()
    {
      if (MWMCR.MCRAppInitialized)
      {
        Assembly assembly= Assembly.GetExecutingAssembly();

        string ctfFilePath= assembly.Location;

        int lastDelimiter= ctfFilePath.LastIndexOf(@"\");

        ctfFilePath= ctfFilePath.Remove(lastDelimiter, (ctfFilePath.Length - lastDelimiter));

        string ctfFileName = "BwnFunctions.ctf";

        Stream embeddedCtfStream = null;

        String[] resourceStrings = assembly.GetManifestResourceNames();

        foreach (String name in resourceStrings)
        {
          if (name.Contains(ctfFileName))
          {
            embeddedCtfStream = assembly.GetManifestResourceStream(name);
            break;
          }
        }
        mcr= new MWMCR("",
                       ctfFilePath, embeddedCtfStream, true);
      }
      else
      {
        throw new ApplicationException("MWArray assembly could not be initialized");
      }
    }


    /// <summary>
    /// Constructs a new instance of the BwnFunctions class.
    /// </summary>
    public BwnFunctions()
    {
    }


    #endregion Constructors

    #region Finalize

    /// <summary internal= "true">
    /// Class destructor called by the CLR garbage collector.
    /// </summary>
    ~BwnFunctions()
    {
      Dispose(false);
    }


    /// <summary>
    /// Frees the native resources associated with this object
    /// </summary>
    public void Dispose()
    {
      Dispose(true);

      GC.SuppressFinalize(this);
    }


    /// <summary internal= "true">
    /// Internal dispose function
    /// </summary>
    protected virtual void Dispose(bool disposing)
    {
      if (!disposed)
      {
        disposed= true;

        if (disposing)
        {
          // Free managed resources;
        }

        // Free native resources
      }
    }


    #endregion Finalize

    #region Methods

    /// <summary>
    /// Provides a void output, 0-input Objectinterface to the Initialize M-function.
    /// </summary>
    /// <remarks>
    /// </remarks>
    ///
    public void Initialize()
    {
      mcr.EvaluateFunction(0, "Initialize", new Object[]{});
    }


    /// <summary>
    /// Provides a void output, 1-input Objectinterface to the Initialize M-function.
    /// </summary>
    /// <remarks>
    /// </remarks>
    /// <param name="varargin">Array of Objects representing the input arguments 1
    /// through varargin.length</param>
    ///
    public void Initialize(params Object[] varargin)
    {
      mcr.EvaluateFunction(0, "Initialize", varargin);
    }


    /// <summary>
    /// Provides the standard 0-input Object interface to the Initialize M-function.
    /// </summary>
    /// <remarks>
    /// </remarks>
    /// <param name="numArgsOut">The number of output arguments to return.</param>
    /// <returns>An Array of length "numArgsOut" containing the output
    /// arguments.</returns>
    ///
    public Object[] Initialize(int numArgsOut)
    {
      return mcr.EvaluateFunction(numArgsOut, "Initialize", new Object[]{});
    }


    /// <summary>
    /// Provides the standard 1-input Object interface to the Initialize M-function.
    /// </summary>
    /// <remarks>
    /// </remarks>
    /// <param name="numArgsOut">The number of output arguments to return.</param>
    /// <param name="varargin">Array of Objects representing the input arguments 1
    /// through varargin.length</param>
    /// <returns>An Array of length "numArgsOut" containing the output
    /// arguments.</returns>
    ///
    public Object[] Initialize(int numArgsOut, params Object[] varargin)
    {
      return mcr.EvaluateFunction(numArgsOut, "Initialize", varargin);
    }


    /// <summary>
    /// Provides a single output, 0-input Objectinterface to the InterpolateToLine
    /// M-function.
    /// </summary>
    /// <remarks>
    /// M-Documentation:
    /// Calculate coordinates of line
    /// </remarks>
    /// <returns>An Object containing the first output argument.</returns>
    ///
    public Object InterpolateToLine()
    {
      return mcr.EvaluateFunction("InterpolateToLine", new Object[]{});
    }


    /// <summary>
    /// Provides a single output, 1-input Objectinterface to the InterpolateToLine
    /// M-function.
    /// </summary>
    /// <remarks>
    /// M-Documentation:
    /// Calculate coordinates of line
    /// </remarks>
    /// <param name="ncfile">Input argument #1</param>
    /// <returns>An Object containing the first output argument.</returns>
    ///
    public Object InterpolateToLine(Object ncfile)
    {
      return mcr.EvaluateFunction("InterpolateToLine", ncfile);
    }


    /// <summary>
    /// Provides a single output, 2-input Objectinterface to the InterpolateToLine
    /// M-function.
    /// </summary>
    /// <remarks>
    /// M-Documentation:
    /// Calculate coordinates of line
    /// </remarks>
    /// <param name="ncfile">Input argument #1</param>
    /// <param name="ncVariable">Input argument #2</param>
    /// <returns>An Object containing the first output argument.</returns>
    ///
    public Object InterpolateToLine(Object ncfile, Object ncVariable)
    {
      return mcr.EvaluateFunction("InterpolateToLine", ncfile, ncVariable);
    }


    /// <summary>
    /// Provides a single output, 3-input Objectinterface to the InterpolateToLine
    /// M-function.
    /// </summary>
    /// <remarks>
    /// M-Documentation:
    /// Calculate coordinates of line
    /// </remarks>
    /// <param name="ncfile">Input argument #1</param>
    /// <param name="ncVariable">Input argument #2</param>
    /// <param name="Centre">Input argument #3</param>
    /// <returns>An Object containing the first output argument.</returns>
    ///
    public Object InterpolateToLine(Object ncfile, Object ncVariable, Object Centre)
    {
      return mcr.EvaluateFunction("InterpolateToLine", ncfile, ncVariable, Centre);
    }


    /// <summary>
    /// Provides a single output, 4-input Objectinterface to the InterpolateToLine
    /// M-function.
    /// </summary>
    /// <remarks>
    /// M-Documentation:
    /// Calculate coordinates of line
    /// </remarks>
    /// <param name="ncfile">Input argument #1</param>
    /// <param name="ncVariable">Input argument #2</param>
    /// <param name="Centre">Input argument #3</param>
    /// <param name="Vertex">Input argument #4</param>
    /// <returns>An Object containing the first output argument.</returns>
    ///
    public Object InterpolateToLine(Object ncfile, Object ncVariable, Object Centre, 
                              Object Vertex)
    {
      return mcr.EvaluateFunction("InterpolateToLine", ncfile, ncVariable, Centre, Vertex);
    }


    /// <summary>
    /// Provides a single output, 5-input Objectinterface to the InterpolateToLine
    /// M-function.
    /// </summary>
    /// <remarks>
    /// M-Documentation:
    /// Calculate coordinates of line
    /// </remarks>
    /// <param name="ncfile">Input argument #1</param>
    /// <param name="ncVariable">Input argument #2</param>
    /// <param name="Centre">Input argument #3</param>
    /// <param name="Vertex">Input argument #4</param>
    /// <param name="varargin">Array of Objects representing the input arguments 5
    /// through varargin.length+4</param>
    /// <returns>An Object containing the first output argument.</returns>
    ///
    public Object InterpolateToLine(Object ncfile, Object ncVariable, Object Centre, 
                              Object Vertex, params Object[] varargin)
    {
      Object[] argsIn= {ncfile, ncVariable, Centre, Vertex, varargin};

      return mcr.EvaluateFunction("InterpolateToLine", argsIn);
    }


    /// <summary>
    /// Provides the standard 0-input Object interface to the InterpolateToLine
    /// M-function.
    /// </summary>
    /// <remarks>
    /// M-Documentation:
    /// Calculate coordinates of line
    /// </remarks>
    /// <param name="numArgsOut">The number of output arguments to return.</param>
    /// <returns>An Array of length "numArgsOut" containing the output
    /// arguments.</returns>
    ///
    public Object[] InterpolateToLine(int numArgsOut)
    {
      return mcr.EvaluateFunction(numArgsOut, "InterpolateToLine", new Object[]{});
    }


    /// <summary>
    /// Provides the standard 1-input Object interface to the InterpolateToLine
    /// M-function.
    /// </summary>
    /// <remarks>
    /// M-Documentation:
    /// Calculate coordinates of line
    /// </remarks>
    /// <param name="numArgsOut">The number of output arguments to return.</param>
    /// <param name="ncfile">Input argument #1</param>
    /// <returns>An Array of length "numArgsOut" containing the output
    /// arguments.</returns>
    ///
    public Object[] InterpolateToLine(int numArgsOut, Object ncfile)
    {
      return mcr.EvaluateFunction(numArgsOut, "InterpolateToLine", ncfile);
    }


    /// <summary>
    /// Provides the standard 2-input Object interface to the InterpolateToLine
    /// M-function.
    /// </summary>
    /// <remarks>
    /// M-Documentation:
    /// Calculate coordinates of line
    /// </remarks>
    /// <param name="numArgsOut">The number of output arguments to return.</param>
    /// <param name="ncfile">Input argument #1</param>
    /// <param name="ncVariable">Input argument #2</param>
    /// <returns>An Array of length "numArgsOut" containing the output
    /// arguments.</returns>
    ///
    public Object[] InterpolateToLine(int numArgsOut, Object ncfile, Object ncVariable)
    {
      return mcr.EvaluateFunction(numArgsOut, "InterpolateToLine", ncfile, ncVariable);
    }


    /// <summary>
    /// Provides the standard 3-input Object interface to the InterpolateToLine
    /// M-function.
    /// </summary>
    /// <remarks>
    /// M-Documentation:
    /// Calculate coordinates of line
    /// </remarks>
    /// <param name="numArgsOut">The number of output arguments to return.</param>
    /// <param name="ncfile">Input argument #1</param>
    /// <param name="ncVariable">Input argument #2</param>
    /// <param name="Centre">Input argument #3</param>
    /// <returns>An Array of length "numArgsOut" containing the output
    /// arguments.</returns>
    ///
    public Object[] InterpolateToLine(int numArgsOut, Object ncfile, Object ncVariable, 
                                Object Centre)
    {
      return mcr.EvaluateFunction(numArgsOut, "InterpolateToLine", ncfile, ncVariable, Centre);
    }


    /// <summary>
    /// Provides the standard 4-input Object interface to the InterpolateToLine
    /// M-function.
    /// </summary>
    /// <remarks>
    /// M-Documentation:
    /// Calculate coordinates of line
    /// </remarks>
    /// <param name="numArgsOut">The number of output arguments to return.</param>
    /// <param name="ncfile">Input argument #1</param>
    /// <param name="ncVariable">Input argument #2</param>
    /// <param name="Centre">Input argument #3</param>
    /// <param name="Vertex">Input argument #4</param>
    /// <returns>An Array of length "numArgsOut" containing the output
    /// arguments.</returns>
    ///
    public Object[] InterpolateToLine(int numArgsOut, Object ncfile, Object ncVariable, 
                                Object Centre, Object Vertex)
    {
      return mcr.EvaluateFunction(numArgsOut, "InterpolateToLine", ncfile, ncVariable, Centre, Vertex);
    }


    /// <summary>
    /// Provides the standard 5-input Object interface to the InterpolateToLine
    /// M-function.
    /// </summary>
    /// <remarks>
    /// M-Documentation:
    /// Calculate coordinates of line
    /// </remarks>
    /// <param name="numArgsOut">The number of output arguments to return.</param>
    /// <param name="ncfile">Input argument #1</param>
    /// <param name="ncVariable">Input argument #2</param>
    /// <param name="Centre">Input argument #3</param>
    /// <param name="Vertex">Input argument #4</param>
    /// <param name="varargin">Array of Objects representing the input arguments 5
    /// through varargin.length+4</param>
    /// <returns>An Array of length "numArgsOut" containing the output
    /// arguments.</returns>
    ///
    public Object[] InterpolateToLine(int numArgsOut, Object ncfile, Object ncVariable, 
                                Object Centre, Object Vertex, params Object[] varargin)
    {
      Object[] argsIn= {ncfile, ncVariable, Centre, Vertex, varargin};

      return mcr.EvaluateFunction(numArgsOut, "InterpolateToLine", argsIn);
    }


    /// <summary>
    /// Provides a single output, 0-input Objectinterface to the PlotTimeSeries
    /// M-function.
    /// </summary>
    /// <remarks>
    /// M-Documentation:
    /// function outputPng = PlotTimeSeries(ncfile,ncVariable, startDay, startTime,
    /// stopDay, stopTime,varargin)
    /// Convert to datenum
    /// start = datenum([startDay ' ' startTime]);   convert to string with
    /// datestr(t1,31)
    /// </remarks>
    /// <returns>An Object containing the first output argument.</returns>
    ///
    public Object PlotTimeSeries()
    {
      return mcr.EvaluateFunction("PlotTimeSeries", new Object[]{});
    }


    /// <summary>
    /// Provides a single output, 1-input Objectinterface to the PlotTimeSeries
    /// M-function.
    /// </summary>
    /// <remarks>
    /// M-Documentation:
    /// function outputPng = PlotTimeSeries(ncfile,ncVariable, startDay, startTime,
    /// stopDay, stopTime,varargin)
    /// Convert to datenum
    /// start = datenum([startDay ' ' startTime]);   convert to string with
    /// datestr(t1,31)
    /// </remarks>
    /// <param name="ncfile">Input argument #1</param>
    /// <returns>An Object containing the first output argument.</returns>
    ///
    public Object PlotTimeSeries(Object ncfile)
    {
      return mcr.EvaluateFunction("PlotTimeSeries", ncfile);
    }


    /// <summary>
    /// Provides a single output, 2-input Objectinterface to the PlotTimeSeries
    /// M-function.
    /// </summary>
    /// <remarks>
    /// M-Documentation:
    /// function outputPng = PlotTimeSeries(ncfile,ncVariable, startDay, startTime,
    /// stopDay, stopTime,varargin)
    /// Convert to datenum
    /// start = datenum([startDay ' ' startTime]);   convert to string with
    /// datestr(t1,31)
    /// </remarks>
    /// <param name="ncfile">Input argument #1</param>
    /// <param name="ncVariable">Input argument #2</param>
    /// <returns>An Object containing the first output argument.</returns>
    ///
    public Object PlotTimeSeries(Object ncfile, Object ncVariable)
    {
      return mcr.EvaluateFunction("PlotTimeSeries", ncfile, ncVariable);
    }


    /// <summary>
    /// Provides a single output, 3-input Objectinterface to the PlotTimeSeries
    /// M-function.
    /// </summary>
    /// <remarks>
    /// M-Documentation:
    /// function outputPng = PlotTimeSeries(ncfile,ncVariable, startDay, startTime,
    /// stopDay, stopTime,varargin)
    /// Convert to datenum
    /// start = datenum([startDay ' ' startTime]);   convert to string with
    /// datestr(t1,31)
    /// </remarks>
    /// <param name="ncfile">Input argument #1</param>
    /// <param name="ncVariable">Input argument #2</param>
    /// <param name="startDay">Input argument #3</param>
    /// <returns>An Object containing the first output argument.</returns>
    ///
    public Object PlotTimeSeries(Object ncfile, Object ncVariable, Object startDay)
    {
      return mcr.EvaluateFunction("PlotTimeSeries", ncfile, ncVariable, startDay);
    }


    /// <summary>
    /// Provides a single output, 4-input Objectinterface to the PlotTimeSeries
    /// M-function.
    /// </summary>
    /// <remarks>
    /// M-Documentation:
    /// function outputPng = PlotTimeSeries(ncfile,ncVariable, startDay, startTime,
    /// stopDay, stopTime,varargin)
    /// Convert to datenum
    /// start = datenum([startDay ' ' startTime]);   convert to string with
    /// datestr(t1,31)
    /// </remarks>
    /// <param name="ncfile">Input argument #1</param>
    /// <param name="ncVariable">Input argument #2</param>
    /// <param name="startDay">Input argument #3</param>
    /// <param name="startTime">Input argument #4</param>
    /// <returns>An Object containing the first output argument.</returns>
    ///
    public Object PlotTimeSeries(Object ncfile, Object ncVariable, Object startDay, 
                           Object startTime)
    {
      return mcr.EvaluateFunction("PlotTimeSeries", ncfile, ncVariable, startDay, startTime);
    }


    /// <summary>
    /// Provides a single output, 5-input Objectinterface to the PlotTimeSeries
    /// M-function.
    /// </summary>
    /// <remarks>
    /// M-Documentation:
    /// function outputPng = PlotTimeSeries(ncfile,ncVariable, startDay, startTime,
    /// stopDay, stopTime,varargin)
    /// Convert to datenum
    /// start = datenum([startDay ' ' startTime]);   convert to string with
    /// datestr(t1,31)
    /// </remarks>
    /// <param name="ncfile">Input argument #1</param>
    /// <param name="ncVariable">Input argument #2</param>
    /// <param name="startDay">Input argument #3</param>
    /// <param name="startTime">Input argument #4</param>
    /// <param name="stopDay">Input argument #5</param>
    /// <returns>An Object containing the first output argument.</returns>
    ///
    public Object PlotTimeSeries(Object ncfile, Object ncVariable, Object startDay, 
                           Object startTime, Object stopDay)
    {
      return mcr.EvaluateFunction("PlotTimeSeries", ncfile, ncVariable, startDay, startTime, stopDay);
    }


    /// <summary>
    /// Provides a single output, 6-input Objectinterface to the PlotTimeSeries
    /// M-function.
    /// </summary>
    /// <remarks>
    /// M-Documentation:
    /// function outputPng = PlotTimeSeries(ncfile,ncVariable, startDay, startTime,
    /// stopDay, stopTime,varargin)
    /// Convert to datenum
    /// start = datenum([startDay ' ' startTime]);   convert to string with
    /// datestr(t1,31)
    /// </remarks>
    /// <param name="ncfile">Input argument #1</param>
    /// <param name="ncVariable">Input argument #2</param>
    /// <param name="startDay">Input argument #3</param>
    /// <param name="startTime">Input argument #4</param>
    /// <param name="stopDay">Input argument #5</param>
    /// <param name="stopTime">Input argument #6</param>
    /// <returns>An Object containing the first output argument.</returns>
    ///
    public Object PlotTimeSeries(Object ncfile, Object ncVariable, Object startDay, 
                           Object startTime, Object stopDay, Object stopTime)
    {
      return mcr.EvaluateFunction("PlotTimeSeries", ncfile, ncVariable, startDay, startTime, stopDay, stopTime);
    }


    /// <summary>
    /// Provides a single output, 7-input Objectinterface to the PlotTimeSeries
    /// M-function.
    /// </summary>
    /// <remarks>
    /// M-Documentation:
    /// function outputPng = PlotTimeSeries(ncfile,ncVariable, startDay, startTime,
    /// stopDay, stopTime,varargin)
    /// Convert to datenum
    /// start = datenum([startDay ' ' startTime]);   convert to string with
    /// datestr(t1,31)
    /// </remarks>
    /// <param name="ncfile">Input argument #1</param>
    /// <param name="ncVariable">Input argument #2</param>
    /// <param name="startDay">Input argument #3</param>
    /// <param name="startTime">Input argument #4</param>
    /// <param name="stopDay">Input argument #5</param>
    /// <param name="stopTime">Input argument #6</param>
    /// <param name="varargin">Array of Objects representing the input arguments 7
    /// through varargin.length+6</param>
    /// <returns>An Object containing the first output argument.</returns>
    ///
    public Object PlotTimeSeries(Object ncfile, Object ncVariable, Object startDay, 
                           Object startTime, Object stopDay, Object stopTime, params 
                           Object[] varargin)
    {
      Object[] argsIn= {ncfile, ncVariable, startDay, startTime, stopDay, stopTime, varargin};

      return mcr.EvaluateFunction("PlotTimeSeries", argsIn);
    }


    /// <summary>
    /// Provides the standard 0-input Object interface to the PlotTimeSeries M-function.
    /// </summary>
    /// <remarks>
    /// M-Documentation:
    /// function outputPng = PlotTimeSeries(ncfile,ncVariable, startDay, startTime,
    /// stopDay, stopTime,varargin)
    /// Convert to datenum
    /// start = datenum([startDay ' ' startTime]);   convert to string with
    /// datestr(t1,31)
    /// </remarks>
    /// <param name="numArgsOut">The number of output arguments to return.</param>
    /// <returns>An Array of length "numArgsOut" containing the output
    /// arguments.</returns>
    ///
    public Object[] PlotTimeSeries(int numArgsOut)
    {
      return mcr.EvaluateFunction(numArgsOut, "PlotTimeSeries", new Object[]{});
    }


    /// <summary>
    /// Provides the standard 1-input Object interface to the PlotTimeSeries M-function.
    /// </summary>
    /// <remarks>
    /// M-Documentation:
    /// function outputPng = PlotTimeSeries(ncfile,ncVariable, startDay, startTime,
    /// stopDay, stopTime,varargin)
    /// Convert to datenum
    /// start = datenum([startDay ' ' startTime]);   convert to string with
    /// datestr(t1,31)
    /// </remarks>
    /// <param name="numArgsOut">The number of output arguments to return.</param>
    /// <param name="ncfile">Input argument #1</param>
    /// <returns>An Array of length "numArgsOut" containing the output
    /// arguments.</returns>
    ///
    public Object[] PlotTimeSeries(int numArgsOut, Object ncfile)
    {
      return mcr.EvaluateFunction(numArgsOut, "PlotTimeSeries", ncfile);
    }


    /// <summary>
    /// Provides the standard 2-input Object interface to the PlotTimeSeries M-function.
    /// </summary>
    /// <remarks>
    /// M-Documentation:
    /// function outputPng = PlotTimeSeries(ncfile,ncVariable, startDay, startTime,
    /// stopDay, stopTime,varargin)
    /// Convert to datenum
    /// start = datenum([startDay ' ' startTime]);   convert to string with
    /// datestr(t1,31)
    /// </remarks>
    /// <param name="numArgsOut">The number of output arguments to return.</param>
    /// <param name="ncfile">Input argument #1</param>
    /// <param name="ncVariable">Input argument #2</param>
    /// <returns>An Array of length "numArgsOut" containing the output
    /// arguments.</returns>
    ///
    public Object[] PlotTimeSeries(int numArgsOut, Object ncfile, Object ncVariable)
    {
      return mcr.EvaluateFunction(numArgsOut, "PlotTimeSeries", ncfile, ncVariable);
    }


    /// <summary>
    /// Provides the standard 3-input Object interface to the PlotTimeSeries M-function.
    /// </summary>
    /// <remarks>
    /// M-Documentation:
    /// function outputPng = PlotTimeSeries(ncfile,ncVariable, startDay, startTime,
    /// stopDay, stopTime,varargin)
    /// Convert to datenum
    /// start = datenum([startDay ' ' startTime]);   convert to string with
    /// datestr(t1,31)
    /// </remarks>
    /// <param name="numArgsOut">The number of output arguments to return.</param>
    /// <param name="ncfile">Input argument #1</param>
    /// <param name="ncVariable">Input argument #2</param>
    /// <param name="startDay">Input argument #3</param>
    /// <returns>An Array of length "numArgsOut" containing the output
    /// arguments.</returns>
    ///
    public Object[] PlotTimeSeries(int numArgsOut, Object ncfile, Object ncVariable, 
                             Object startDay)
    {
      return mcr.EvaluateFunction(numArgsOut, "PlotTimeSeries", ncfile, ncVariable, startDay);
    }


    /// <summary>
    /// Provides the standard 4-input Object interface to the PlotTimeSeries M-function.
    /// </summary>
    /// <remarks>
    /// M-Documentation:
    /// function outputPng = PlotTimeSeries(ncfile,ncVariable, startDay, startTime,
    /// stopDay, stopTime,varargin)
    /// Convert to datenum
    /// start = datenum([startDay ' ' startTime]);   convert to string with
    /// datestr(t1,31)
    /// </remarks>
    /// <param name="numArgsOut">The number of output arguments to return.</param>
    /// <param name="ncfile">Input argument #1</param>
    /// <param name="ncVariable">Input argument #2</param>
    /// <param name="startDay">Input argument #3</param>
    /// <param name="startTime">Input argument #4</param>
    /// <returns>An Array of length "numArgsOut" containing the output
    /// arguments.</returns>
    ///
    public Object[] PlotTimeSeries(int numArgsOut, Object ncfile, Object ncVariable, 
                             Object startDay, Object startTime)
    {
      return mcr.EvaluateFunction(numArgsOut, "PlotTimeSeries", ncfile, ncVariable, startDay, startTime);
    }


    /// <summary>
    /// Provides the standard 5-input Object interface to the PlotTimeSeries M-function.
    /// </summary>
    /// <remarks>
    /// M-Documentation:
    /// function outputPng = PlotTimeSeries(ncfile,ncVariable, startDay, startTime,
    /// stopDay, stopTime,varargin)
    /// Convert to datenum
    /// start = datenum([startDay ' ' startTime]);   convert to string with
    /// datestr(t1,31)
    /// </remarks>
    /// <param name="numArgsOut">The number of output arguments to return.</param>
    /// <param name="ncfile">Input argument #1</param>
    /// <param name="ncVariable">Input argument #2</param>
    /// <param name="startDay">Input argument #3</param>
    /// <param name="startTime">Input argument #4</param>
    /// <param name="stopDay">Input argument #5</param>
    /// <returns>An Array of length "numArgsOut" containing the output
    /// arguments.</returns>
    ///
    public Object[] PlotTimeSeries(int numArgsOut, Object ncfile, Object ncVariable, 
                             Object startDay, Object startTime, Object stopDay)
    {
      return mcr.EvaluateFunction(numArgsOut, "PlotTimeSeries", ncfile, ncVariable, startDay, startTime, stopDay);
    }


    /// <summary>
    /// Provides the standard 6-input Object interface to the PlotTimeSeries M-function.
    /// </summary>
    /// <remarks>
    /// M-Documentation:
    /// function outputPng = PlotTimeSeries(ncfile,ncVariable, startDay, startTime,
    /// stopDay, stopTime,varargin)
    /// Convert to datenum
    /// start = datenum([startDay ' ' startTime]);   convert to string with
    /// datestr(t1,31)
    /// </remarks>
    /// <param name="numArgsOut">The number of output arguments to return.</param>
    /// <param name="ncfile">Input argument #1</param>
    /// <param name="ncVariable">Input argument #2</param>
    /// <param name="startDay">Input argument #3</param>
    /// <param name="startTime">Input argument #4</param>
    /// <param name="stopDay">Input argument #5</param>
    /// <param name="stopTime">Input argument #6</param>
    /// <returns>An Array of length "numArgsOut" containing the output
    /// arguments.</returns>
    ///
    public Object[] PlotTimeSeries(int numArgsOut, Object ncfile, Object ncVariable, 
                             Object startDay, Object startTime, Object stopDay, Object 
                             stopTime)
    {
      return mcr.EvaluateFunction(numArgsOut, "PlotTimeSeries", ncfile, ncVariable, startDay, startTime, stopDay, stopTime);
    }


    /// <summary>
    /// Provides the standard 7-input Object interface to the PlotTimeSeries M-function.
    /// </summary>
    /// <remarks>
    /// M-Documentation:
    /// function outputPng = PlotTimeSeries(ncfile,ncVariable, startDay, startTime,
    /// stopDay, stopTime,varargin)
    /// Convert to datenum
    /// start = datenum([startDay ' ' startTime]);   convert to string with
    /// datestr(t1,31)
    /// </remarks>
    /// <param name="numArgsOut">The number of output arguments to return.</param>
    /// <param name="ncfile">Input argument #1</param>
    /// <param name="ncVariable">Input argument #2</param>
    /// <param name="startDay">Input argument #3</param>
    /// <param name="startTime">Input argument #4</param>
    /// <param name="stopDay">Input argument #5</param>
    /// <param name="stopTime">Input argument #6</param>
    /// <param name="varargin">Array of Objects representing the input arguments 7
    /// through varargin.length+6</param>
    /// <returns>An Array of length "numArgsOut" containing the output
    /// arguments.</returns>
    ///
    public Object[] PlotTimeSeries(int numArgsOut, Object ncfile, Object ncVariable, 
                             Object startDay, Object startTime, Object stopDay, Object 
                             stopTime, params Object[] varargin)
    {
      Object[] argsIn= {ncfile, ncVariable, startDay, startTime, stopDay, stopTime, varargin};

      return mcr.EvaluateFunction(numArgsOut, "PlotTimeSeries", argsIn);
    }


    /// <summary>
    /// Provides a single output, 0-input Objectinterface to the WaveTransformationTable
    /// M-function.
    /// </summary>
    /// <remarks>
    /// M-Documentation:
    /// WAVETRANSFORMATIONTABLE  wrapper function for Transform
    /// THis calls Transform which uses waveRose. WaveRose is not a public
    /// function and therefore not part of this repos. To compile the code
    /// successfully one should add the waveRose function to the search path
    /// when compiling.
    /// Syntax:
    /// outputPng = WaveTransformationTable(startTime,stopTime,lon,lat,varargin)
    /// Input:
    /// startTime = the start time as a string in the form "11/10/1980"
    /// endTime   = the end time as a string in the form "11/10/1980"
    /// lon / lat = a double with the longitude or latitude
    /// varargin  = can contain a directory name that is used to publish the
    /// result files
    /// Output:
    /// outputPng = path of the output file(s)
    /// Example
    /// WaveTransformationTable
    /// See also Transform
    /// </remarks>
    /// <returns>An Object containing the first output argument.</returns>
    ///
    public Object WaveTransformationTable()
    {
      return mcr.EvaluateFunction("WaveTransformationTable", new Object[]{});
    }


    /// <summary>
    /// Provides a single output, 1-input Objectinterface to the WaveTransformationTable
    /// M-function.
    /// </summary>
    /// <remarks>
    /// M-Documentation:
    /// WAVETRANSFORMATIONTABLE  wrapper function for Transform
    /// THis calls Transform which uses waveRose. WaveRose is not a public
    /// function and therefore not part of this repos. To compile the code
    /// successfully one should add the waveRose function to the search path
    /// when compiling.
    /// Syntax:
    /// outputPng = WaveTransformationTable(startTime,stopTime,lon,lat,varargin)
    /// Input:
    /// startTime = the start time as a string in the form "11/10/1980"
    /// endTime   = the end time as a string in the form "11/10/1980"
    /// lon / lat = a double with the longitude or latitude
    /// varargin  = can contain a directory name that is used to publish the
    /// result files
    /// Output:
    /// outputPng = path of the output file(s)
    /// Example
    /// WaveTransformationTable
    /// See also Transform
    /// </remarks>
    /// <param name="startDay">Input argument #1</param>
    /// <returns>An Object containing the first output argument.</returns>
    ///
    public Object WaveTransformationTable(Object startDay)
    {
      return mcr.EvaluateFunction("WaveTransformationTable", startDay);
    }


    /// <summary>
    /// Provides a single output, 2-input Objectinterface to the WaveTransformationTable
    /// M-function.
    /// </summary>
    /// <remarks>
    /// M-Documentation:
    /// WAVETRANSFORMATIONTABLE  wrapper function for Transform
    /// THis calls Transform which uses waveRose. WaveRose is not a public
    /// function and therefore not part of this repos. To compile the code
    /// successfully one should add the waveRose function to the search path
    /// when compiling.
    /// Syntax:
    /// outputPng = WaveTransformationTable(startTime,stopTime,lon,lat,varargin)
    /// Input:
    /// startTime = the start time as a string in the form "11/10/1980"
    /// endTime   = the end time as a string in the form "11/10/1980"
    /// lon / lat = a double with the longitude or latitude
    /// varargin  = can contain a directory name that is used to publish the
    /// result files
    /// Output:
    /// outputPng = path of the output file(s)
    /// Example
    /// WaveTransformationTable
    /// See also Transform
    /// </remarks>
    /// <param name="startDay">Input argument #1</param>
    /// <param name="startTime">Input argument #2</param>
    /// <returns>An Object containing the first output argument.</returns>
    ///
    public Object WaveTransformationTable(Object startDay, Object startTime)
    {
      return mcr.EvaluateFunction("WaveTransformationTable", startDay, startTime);
    }


    /// <summary>
    /// Provides a single output, 3-input Objectinterface to the WaveTransformationTable
    /// M-function.
    /// </summary>
    /// <remarks>
    /// M-Documentation:
    /// WAVETRANSFORMATIONTABLE  wrapper function for Transform
    /// THis calls Transform which uses waveRose. WaveRose is not a public
    /// function and therefore not part of this repos. To compile the code
    /// successfully one should add the waveRose function to the search path
    /// when compiling.
    /// Syntax:
    /// outputPng = WaveTransformationTable(startTime,stopTime,lon,lat,varargin)
    /// Input:
    /// startTime = the start time as a string in the form "11/10/1980"
    /// endTime   = the end time as a string in the form "11/10/1980"
    /// lon / lat = a double with the longitude or latitude
    /// varargin  = can contain a directory name that is used to publish the
    /// result files
    /// Output:
    /// outputPng = path of the output file(s)
    /// Example
    /// WaveTransformationTable
    /// See also Transform
    /// </remarks>
    /// <param name="startDay">Input argument #1</param>
    /// <param name="startTime">Input argument #2</param>
    /// <param name="stopDay">Input argument #3</param>
    /// <returns>An Object containing the first output argument.</returns>
    ///
    public Object WaveTransformationTable(Object startDay, Object startTime, Object 
                                    stopDay)
    {
      return mcr.EvaluateFunction("WaveTransformationTable", startDay, startTime, stopDay);
    }


    /// <summary>
    /// Provides a single output, 4-input Objectinterface to the WaveTransformationTable
    /// M-function.
    /// </summary>
    /// <remarks>
    /// M-Documentation:
    /// WAVETRANSFORMATIONTABLE  wrapper function for Transform
    /// THis calls Transform which uses waveRose. WaveRose is not a public
    /// function and therefore not part of this repos. To compile the code
    /// successfully one should add the waveRose function to the search path
    /// when compiling.
    /// Syntax:
    /// outputPng = WaveTransformationTable(startTime,stopTime,lon,lat,varargin)
    /// Input:
    /// startTime = the start time as a string in the form "11/10/1980"
    /// endTime   = the end time as a string in the form "11/10/1980"
    /// lon / lat = a double with the longitude or latitude
    /// varargin  = can contain a directory name that is used to publish the
    /// result files
    /// Output:
    /// outputPng = path of the output file(s)
    /// Example
    /// WaveTransformationTable
    /// See also Transform
    /// </remarks>
    /// <param name="startDay">Input argument #1</param>
    /// <param name="startTime">Input argument #2</param>
    /// <param name="stopDay">Input argument #3</param>
    /// <param name="stopTime">Input argument #4</param>
    /// <returns>An Object containing the first output argument.</returns>
    ///
    public Object WaveTransformationTable(Object startDay, Object startTime, Object 
                                    stopDay, Object stopTime)
    {
      return mcr.EvaluateFunction("WaveTransformationTable", startDay, startTime, stopDay, stopTime);
    }


    /// <summary>
    /// Provides a single output, 5-input Objectinterface to the WaveTransformationTable
    /// M-function.
    /// </summary>
    /// <remarks>
    /// M-Documentation:
    /// WAVETRANSFORMATIONTABLE  wrapper function for Transform
    /// THis calls Transform which uses waveRose. WaveRose is not a public
    /// function and therefore not part of this repos. To compile the code
    /// successfully one should add the waveRose function to the search path
    /// when compiling.
    /// Syntax:
    /// outputPng = WaveTransformationTable(startTime,stopTime,lon,lat,varargin)
    /// Input:
    /// startTime = the start time as a string in the form "11/10/1980"
    /// endTime   = the end time as a string in the form "11/10/1980"
    /// lon / lat = a double with the longitude or latitude
    /// varargin  = can contain a directory name that is used to publish the
    /// result files
    /// Output:
    /// outputPng = path of the output file(s)
    /// Example
    /// WaveTransformationTable
    /// See also Transform
    /// </remarks>
    /// <param name="startDay">Input argument #1</param>
    /// <param name="startTime">Input argument #2</param>
    /// <param name="stopDay">Input argument #3</param>
    /// <param name="stopTime">Input argument #4</param>
    /// <param name="lon">Input argument #5</param>
    /// <returns>An Object containing the first output argument.</returns>
    ///
    public Object WaveTransformationTable(Object startDay, Object startTime, Object 
                                    stopDay, Object stopTime, Object lon)
    {
      return mcr.EvaluateFunction("WaveTransformationTable", startDay, startTime, stopDay, stopTime, lon);
    }


    /// <summary>
    /// Provides a single output, 6-input Objectinterface to the WaveTransformationTable
    /// M-function.
    /// </summary>
    /// <remarks>
    /// M-Documentation:
    /// WAVETRANSFORMATIONTABLE  wrapper function for Transform
    /// THis calls Transform which uses waveRose. WaveRose is not a public
    /// function and therefore not part of this repos. To compile the code
    /// successfully one should add the waveRose function to the search path
    /// when compiling.
    /// Syntax:
    /// outputPng = WaveTransformationTable(startTime,stopTime,lon,lat,varargin)
    /// Input:
    /// startTime = the start time as a string in the form "11/10/1980"
    /// endTime   = the end time as a string in the form "11/10/1980"
    /// lon / lat = a double with the longitude or latitude
    /// varargin  = can contain a directory name that is used to publish the
    /// result files
    /// Output:
    /// outputPng = path of the output file(s)
    /// Example
    /// WaveTransformationTable
    /// See also Transform
    /// </remarks>
    /// <param name="startDay">Input argument #1</param>
    /// <param name="startTime">Input argument #2</param>
    /// <param name="stopDay">Input argument #3</param>
    /// <param name="stopTime">Input argument #4</param>
    /// <param name="lon">Input argument #5</param>
    /// <param name="lat">Input argument #6</param>
    /// <returns>An Object containing the first output argument.</returns>
    ///
    public Object WaveTransformationTable(Object startDay, Object startTime, Object 
                                    stopDay, Object stopTime, Object lon, Object lat)
    {
      return mcr.EvaluateFunction("WaveTransformationTable", startDay, startTime, stopDay, stopTime, lon, lat);
    }


    /// <summary>
    /// Provides a single output, 7-input Objectinterface to the WaveTransformationTable
    /// M-function.
    /// </summary>
    /// <remarks>
    /// M-Documentation:
    /// WAVETRANSFORMATIONTABLE  wrapper function for Transform
    /// THis calls Transform which uses waveRose. WaveRose is not a public
    /// function and therefore not part of this repos. To compile the code
    /// successfully one should add the waveRose function to the search path
    /// when compiling.
    /// Syntax:
    /// outputPng = WaveTransformationTable(startTime,stopTime,lon,lat,varargin)
    /// Input:
    /// startTime = the start time as a string in the form "11/10/1980"
    /// endTime   = the end time as a string in the form "11/10/1980"
    /// lon / lat = a double with the longitude or latitude
    /// varargin  = can contain a directory name that is used to publish the
    /// result files
    /// Output:
    /// outputPng = path of the output file(s)
    /// Example
    /// WaveTransformationTable
    /// See also Transform
    /// </remarks>
    /// <param name="startDay">Input argument #1</param>
    /// <param name="startTime">Input argument #2</param>
    /// <param name="stopDay">Input argument #3</param>
    /// <param name="stopTime">Input argument #4</param>
    /// <param name="lon">Input argument #5</param>
    /// <param name="lat">Input argument #6</param>
    /// <param name="varargin">Array of Objects representing the input arguments 7
    /// through varargin.length+6</param>
    /// <returns>An Object containing the first output argument.</returns>
    ///
    public Object WaveTransformationTable(Object startDay, Object startTime, Object 
                                    stopDay, Object stopTime, Object lon, Object lat, 
                                    params Object[] varargin)
    {
      Object[] argsIn= {startDay, startTime, stopDay, stopTime, lon, lat, varargin};

      return mcr.EvaluateFunction("WaveTransformationTable", argsIn);
    }


    /// <summary>
    /// Provides the standard 0-input Object interface to the WaveTransformationTable
    /// M-function.
    /// </summary>
    /// <remarks>
    /// M-Documentation:
    /// WAVETRANSFORMATIONTABLE  wrapper function for Transform
    /// THis calls Transform which uses waveRose. WaveRose is not a public
    /// function and therefore not part of this repos. To compile the code
    /// successfully one should add the waveRose function to the search path
    /// when compiling.
    /// Syntax:
    /// outputPng = WaveTransformationTable(startTime,stopTime,lon,lat,varargin)
    /// Input:
    /// startTime = the start time as a string in the form "11/10/1980"
    /// endTime   = the end time as a string in the form "11/10/1980"
    /// lon / lat = a double with the longitude or latitude
    /// varargin  = can contain a directory name that is used to publish the
    /// result files
    /// Output:
    /// outputPng = path of the output file(s)
    /// Example
    /// WaveTransformationTable
    /// See also Transform
    /// </remarks>
    /// <param name="numArgsOut">The number of output arguments to return.</param>
    /// <returns>An Array of length "numArgsOut" containing the output
    /// arguments.</returns>
    ///
    public Object[] WaveTransformationTable(int numArgsOut)
    {
      return mcr.EvaluateFunction(numArgsOut, "WaveTransformationTable", new Object[]{});
    }


    /// <summary>
    /// Provides the standard 1-input Object interface to the WaveTransformationTable
    /// M-function.
    /// </summary>
    /// <remarks>
    /// M-Documentation:
    /// WAVETRANSFORMATIONTABLE  wrapper function for Transform
    /// THis calls Transform which uses waveRose. WaveRose is not a public
    /// function and therefore not part of this repos. To compile the code
    /// successfully one should add the waveRose function to the search path
    /// when compiling.
    /// Syntax:
    /// outputPng = WaveTransformationTable(startTime,stopTime,lon,lat,varargin)
    /// Input:
    /// startTime = the start time as a string in the form "11/10/1980"
    /// endTime   = the end time as a string in the form "11/10/1980"
    /// lon / lat = a double with the longitude or latitude
    /// varargin  = can contain a directory name that is used to publish the
    /// result files
    /// Output:
    /// outputPng = path of the output file(s)
    /// Example
    /// WaveTransformationTable
    /// See also Transform
    /// </remarks>
    /// <param name="numArgsOut">The number of output arguments to return.</param>
    /// <param name="startDay">Input argument #1</param>
    /// <returns>An Array of length "numArgsOut" containing the output
    /// arguments.</returns>
    ///
    public Object[] WaveTransformationTable(int numArgsOut, Object startDay)
    {
      return mcr.EvaluateFunction(numArgsOut, "WaveTransformationTable", startDay);
    }


    /// <summary>
    /// Provides the standard 2-input Object interface to the WaveTransformationTable
    /// M-function.
    /// </summary>
    /// <remarks>
    /// M-Documentation:
    /// WAVETRANSFORMATIONTABLE  wrapper function for Transform
    /// THis calls Transform which uses waveRose. WaveRose is not a public
    /// function and therefore not part of this repos. To compile the code
    /// successfully one should add the waveRose function to the search path
    /// when compiling.
    /// Syntax:
    /// outputPng = WaveTransformationTable(startTime,stopTime,lon,lat,varargin)
    /// Input:
    /// startTime = the start time as a string in the form "11/10/1980"
    /// endTime   = the end time as a string in the form "11/10/1980"
    /// lon / lat = a double with the longitude or latitude
    /// varargin  = can contain a directory name that is used to publish the
    /// result files
    /// Output:
    /// outputPng = path of the output file(s)
    /// Example
    /// WaveTransformationTable
    /// See also Transform
    /// </remarks>
    /// <param name="numArgsOut">The number of output arguments to return.</param>
    /// <param name="startDay">Input argument #1</param>
    /// <param name="startTime">Input argument #2</param>
    /// <returns>An Array of length "numArgsOut" containing the output
    /// arguments.</returns>
    ///
    public Object[] WaveTransformationTable(int numArgsOut, Object startDay, Object 
                                      startTime)
    {
      return mcr.EvaluateFunction(numArgsOut, "WaveTransformationTable", startDay, startTime);
    }


    /// <summary>
    /// Provides the standard 3-input Object interface to the WaveTransformationTable
    /// M-function.
    /// </summary>
    /// <remarks>
    /// M-Documentation:
    /// WAVETRANSFORMATIONTABLE  wrapper function for Transform
    /// THis calls Transform which uses waveRose. WaveRose is not a public
    /// function and therefore not part of this repos. To compile the code
    /// successfully one should add the waveRose function to the search path
    /// when compiling.
    /// Syntax:
    /// outputPng = WaveTransformationTable(startTime,stopTime,lon,lat,varargin)
    /// Input:
    /// startTime = the start time as a string in the form "11/10/1980"
    /// endTime   = the end time as a string in the form "11/10/1980"
    /// lon / lat = a double with the longitude or latitude
    /// varargin  = can contain a directory name that is used to publish the
    /// result files
    /// Output:
    /// outputPng = path of the output file(s)
    /// Example
    /// WaveTransformationTable
    /// See also Transform
    /// </remarks>
    /// <param name="numArgsOut">The number of output arguments to return.</param>
    /// <param name="startDay">Input argument #1</param>
    /// <param name="startTime">Input argument #2</param>
    /// <param name="stopDay">Input argument #3</param>
    /// <returns>An Array of length "numArgsOut" containing the output
    /// arguments.</returns>
    ///
    public Object[] WaveTransformationTable(int numArgsOut, Object startDay, Object 
                                      startTime, Object stopDay)
    {
      return mcr.EvaluateFunction(numArgsOut, "WaveTransformationTable", startDay, startTime, stopDay);
    }


    /// <summary>
    /// Provides the standard 4-input Object interface to the WaveTransformationTable
    /// M-function.
    /// </summary>
    /// <remarks>
    /// M-Documentation:
    /// WAVETRANSFORMATIONTABLE  wrapper function for Transform
    /// THis calls Transform which uses waveRose. WaveRose is not a public
    /// function and therefore not part of this repos. To compile the code
    /// successfully one should add the waveRose function to the search path
    /// when compiling.
    /// Syntax:
    /// outputPng = WaveTransformationTable(startTime,stopTime,lon,lat,varargin)
    /// Input:
    /// startTime = the start time as a string in the form "11/10/1980"
    /// endTime   = the end time as a string in the form "11/10/1980"
    /// lon / lat = a double with the longitude or latitude
    /// varargin  = can contain a directory name that is used to publish the
    /// result files
    /// Output:
    /// outputPng = path of the output file(s)
    /// Example
    /// WaveTransformationTable
    /// See also Transform
    /// </remarks>
    /// <param name="numArgsOut">The number of output arguments to return.</param>
    /// <param name="startDay">Input argument #1</param>
    /// <param name="startTime">Input argument #2</param>
    /// <param name="stopDay">Input argument #3</param>
    /// <param name="stopTime">Input argument #4</param>
    /// <returns>An Array of length "numArgsOut" containing the output
    /// arguments.</returns>
    ///
    public Object[] WaveTransformationTable(int numArgsOut, Object startDay, Object 
                                      startTime, Object stopDay, Object stopTime)
    {
      return mcr.EvaluateFunction(numArgsOut, "WaveTransformationTable", startDay, startTime, stopDay, stopTime);
    }


    /// <summary>
    /// Provides the standard 5-input Object interface to the WaveTransformationTable
    /// M-function.
    /// </summary>
    /// <remarks>
    /// M-Documentation:
    /// WAVETRANSFORMATIONTABLE  wrapper function for Transform
    /// THis calls Transform which uses waveRose. WaveRose is not a public
    /// function and therefore not part of this repos. To compile the code
    /// successfully one should add the waveRose function to the search path
    /// when compiling.
    /// Syntax:
    /// outputPng = WaveTransformationTable(startTime,stopTime,lon,lat,varargin)
    /// Input:
    /// startTime = the start time as a string in the form "11/10/1980"
    /// endTime   = the end time as a string in the form "11/10/1980"
    /// lon / lat = a double with the longitude or latitude
    /// varargin  = can contain a directory name that is used to publish the
    /// result files
    /// Output:
    /// outputPng = path of the output file(s)
    /// Example
    /// WaveTransformationTable
    /// See also Transform
    /// </remarks>
    /// <param name="numArgsOut">The number of output arguments to return.</param>
    /// <param name="startDay">Input argument #1</param>
    /// <param name="startTime">Input argument #2</param>
    /// <param name="stopDay">Input argument #3</param>
    /// <param name="stopTime">Input argument #4</param>
    /// <param name="lon">Input argument #5</param>
    /// <returns>An Array of length "numArgsOut" containing the output
    /// arguments.</returns>
    ///
    public Object[] WaveTransformationTable(int numArgsOut, Object startDay, Object 
                                      startTime, Object stopDay, Object stopTime, Object 
                                      lon)
    {
      return mcr.EvaluateFunction(numArgsOut, "WaveTransformationTable", startDay, startTime, stopDay, stopTime, lon);
    }


    /// <summary>
    /// Provides the standard 6-input Object interface to the WaveTransformationTable
    /// M-function.
    /// </summary>
    /// <remarks>
    /// M-Documentation:
    /// WAVETRANSFORMATIONTABLE  wrapper function for Transform
    /// THis calls Transform which uses waveRose. WaveRose is not a public
    /// function and therefore not part of this repos. To compile the code
    /// successfully one should add the waveRose function to the search path
    /// when compiling.
    /// Syntax:
    /// outputPng = WaveTransformationTable(startTime,stopTime,lon,lat,varargin)
    /// Input:
    /// startTime = the start time as a string in the form "11/10/1980"
    /// endTime   = the end time as a string in the form "11/10/1980"
    /// lon / lat = a double with the longitude or latitude
    /// varargin  = can contain a directory name that is used to publish the
    /// result files
    /// Output:
    /// outputPng = path of the output file(s)
    /// Example
    /// WaveTransformationTable
    /// See also Transform
    /// </remarks>
    /// <param name="numArgsOut">The number of output arguments to return.</param>
    /// <param name="startDay">Input argument #1</param>
    /// <param name="startTime">Input argument #2</param>
    /// <param name="stopDay">Input argument #3</param>
    /// <param name="stopTime">Input argument #4</param>
    /// <param name="lon">Input argument #5</param>
    /// <param name="lat">Input argument #6</param>
    /// <returns>An Array of length "numArgsOut" containing the output
    /// arguments.</returns>
    ///
    public Object[] WaveTransformationTable(int numArgsOut, Object startDay, Object 
                                      startTime, Object stopDay, Object stopTime, Object 
                                      lon, Object lat)
    {
      return mcr.EvaluateFunction(numArgsOut, "WaveTransformationTable", startDay, startTime, stopDay, stopTime, lon, lat);
    }


    /// <summary>
    /// Provides the standard 7-input Object interface to the WaveTransformationTable
    /// M-function.
    /// </summary>
    /// <remarks>
    /// M-Documentation:
    /// WAVETRANSFORMATIONTABLE  wrapper function for Transform
    /// THis calls Transform which uses waveRose. WaveRose is not a public
    /// function and therefore not part of this repos. To compile the code
    /// successfully one should add the waveRose function to the search path
    /// when compiling.
    /// Syntax:
    /// outputPng = WaveTransformationTable(startTime,stopTime,lon,lat,varargin)
    /// Input:
    /// startTime = the start time as a string in the form "11/10/1980"
    /// endTime   = the end time as a string in the form "11/10/1980"
    /// lon / lat = a double with the longitude or latitude
    /// varargin  = can contain a directory name that is used to publish the
    /// result files
    /// Output:
    /// outputPng = path of the output file(s)
    /// Example
    /// WaveTransformationTable
    /// See also Transform
    /// </remarks>
    /// <param name="numArgsOut">The number of output arguments to return.</param>
    /// <param name="startDay">Input argument #1</param>
    /// <param name="startTime">Input argument #2</param>
    /// <param name="stopDay">Input argument #3</param>
    /// <param name="stopTime">Input argument #4</param>
    /// <param name="lon">Input argument #5</param>
    /// <param name="lat">Input argument #6</param>
    /// <param name="varargin">Array of Objects representing the input arguments 7
    /// through varargin.length+6</param>
    /// <returns>An Array of length "numArgsOut" containing the output
    /// arguments.</returns>
    ///
    public Object[] WaveTransformationTable(int numArgsOut, Object startDay, Object 
                                      startTime, Object stopDay, Object stopTime, Object 
                                      lon, Object lat, params Object[] varargin)
    {
      Object[] argsIn= {startDay, startTime, stopDay, stopTime, lon, lat, varargin};

      return mcr.EvaluateFunction(numArgsOut, "WaveTransformationTable", argsIn);
    }


    /// <summary>
    /// This method will cause a MATLAB figure window to behave as a modal dialog box.
    /// The method will not return until all the figure windows associated with this
    /// component have been closed.
    /// </summary>
    /// <remarks>
    /// An application should only call this method when required to keep the
    /// MATLAB figure window from disappearing.  Other techniques, such as calling
    /// Console.ReadLine() from the application should be considered where
    /// possible.</remarks>
    ///
    public void WaitForFiguresToDie()
    {
      mcr.WaitForFiguresToDie();
    }



    #endregion Methods

    #region Class Members

    private static MWMCR mcr= null;

    private bool disposed= false;

    #endregion Class Members
  }
}