<?xml version="1.0"?>
<doc>
    <assembly>
        <name>Microsoft.ML.Core</name>
    </assembly>
    <members>
        <member name="T:Microsoft.ML.BestFriendAttribute">
            <summary>
            Intended to be applied to types and members with internal scope to indicate that friend access of this
            internal item is OK from another assembly. This restriction applies only to assemblies that declare the
            <see cref="T:Microsoft.ML.WantsToBeBestFriendsAttribute"/> assembly level attribute. Note that this attribute is not
            transferrable: an internal member with this attribute does not somehow make a containing internal type
            accessible. Conversely, neither does marking an internal type make any unmarked internal members accessible.
            </summary>
        </member>
        <member name="T:Microsoft.ML.WantsToBeBestFriendsAttribute">
            <summary>
            This is an assembly level attribute to signal that friend accesses on this assembly should be checked
            for usage of <see cref="T:Microsoft.ML.BestFriendAttribute"/>. If this attribute is missing, normal access rules for
            friends should apply.
            </summary>
        </member>
        <member name="T:Microsoft.ML.CommandLine.ArgumentAttribute">
            <summary>
            Allows control of command line parsing.
            Attach this attribute to instance fields of types used
            as the destination of command line argument parsing.
            </summary>
        </member>
        <member name="M:Microsoft.ML.CommandLine.ArgumentAttribute.#ctor(Microsoft.ML.CommandLine.ArgumentType)">
            <summary>
            Allows control of command line parsing.
            </summary>
            <param name="type"> Specifies the error checking to be done on the argument. </param>
        </member>
        <member name="P:Microsoft.ML.CommandLine.ArgumentAttribute.Type">
            <summary>
            The error checking to be done on the argument.
            </summary>
        </member>
        <member name="P:Microsoft.ML.CommandLine.ArgumentAttribute.ShortName">
            <summary>
            The short name(s) of the argument.
            Set to null means use the default short name if it does not
            conflict with any other parameter name.
            Set to String.Empty for no short name.
            More than one short name can be separated by commas or spaces.
            This property should not be set for DefaultArgumentAttributes.
            </summary>
        </member>
        <member name="P:Microsoft.ML.CommandLine.ArgumentAttribute.HelpText">
            <summary>
            The help text for the argument.
            </summary>
        </member>
        <member name="P:Microsoft.ML.CommandLine.ArgumentAttribute.Purpose">
            <summary>
            Allows the GUI or other tools to inspect the intended purpose of the argument and pick a correct custom control.
            </summary>
        </member>
        <member name="T:Microsoft.ML.CommandLine.ArgumentType">
            <summary>
            Used to control parsing of command line arguments.
            </summary>
        </member>
        <member name="F:Microsoft.ML.CommandLine.ArgumentType.Required">
            <summary>
            Indicates that this field is required. An error will be displayed
            if it is not present when parsing arguments.
            </summary>
        </member>
        <member name="F:Microsoft.ML.CommandLine.ArgumentType.Unique">
            <summary>
            Only valid in conjunction with Multiple.
            Duplicate values will result in an error.
            </summary>
        </member>
        <member name="F:Microsoft.ML.CommandLine.ArgumentType.Multiple">
            <summary>
            Inidicates that the argument may be specified more than once.
            Only valid if the argument is a collection
            </summary>
        </member>
        <member name="F:Microsoft.ML.CommandLine.ArgumentType.AtMostOnce">
            <summary>
            The default type for non-collection arguments.
            The argument is not required, but an error will be reported if it is specified more than once.
            </summary>
        </member>
        <member name="F:Microsoft.ML.CommandLine.ArgumentType.LastOccurenceWins">
            <summary>
            For non-collection arguments, when the argument is specified more than
            once no error is reported and the value of the argument is the last
            value which occurs in the argument list.
            </summary>
        </member>
        <member name="F:Microsoft.ML.CommandLine.ArgumentType.MultipleUnique">
            <summary>
            The default type for collection arguments.
            The argument is permitted to occur multiple times, but duplicate
            values will cause an error to be reported.
            </summary>
        </member>
        <member name="M:Microsoft.ML.CommandLine.CmdLexer.GetToken(System.Text.StringBuilder)">
            <summary>
            Consume the characters of the next token and append them to the string builder.
            </summary>
        </member>
        <member name="M:Microsoft.ML.CommandLine.CmdQuoter.QuoteValue(System.String,System.Text.StringBuilder,System.Boolean)">
            <summary>
            Returns true if it quoted.
            </summary>
        </member>
        <member name="T:Microsoft.ML.CommandLine.ErrorReporter">
            <summary>
            A delegate used in error reporting.
            </summary>
        </member>
        <member name="T:Microsoft.ML.CommandLine.ICommandLineComponentFactory">
             <summary>
             An IComponentFactory that is used in the command line.
            
             This allows components to be created by name, signature type, and a settings string.
             </summary>
        </member>
        <member name="T:Microsoft.ML.CommandLine.CmdParser">
             <summary>
             Parser for command line arguments.
            
             The parser specification is infered from the instance fields of the object
             specified as the destination of the parse.
             Valid argument types are: int, uint, string, bool, enums
             Also argument types of Array of the above types are also valid.
            
             Error checking options can be controlled by adding a ArgumentAttribute
             to the instance fields of the destination object.
            
             At most one field may be marked with the DefaultArgumentAttribute
             indicating that arguments without a '-' or '/' prefix will be parsed as that argument.
            
             If not specified then the parser will infer default options for parsing each
             instance field. The default long name of the argument is the field name. The
             default short name is the first character of the long name. Long names and explicitly
             specified short names must be unique. Default short names will be used provided that
             the default short name does not conflict with a long name or an explicitly
             specified short name.
            
             Arguments which are array types are collection arguments. Collection
             arguments can be specified multiple times.
             </summary>
        </member>
        <member name="M:Microsoft.ML.CommandLine.CmdParser.ParseArguments(Microsoft.ML.IHostEnvironment,System.String,System.Object)">
            <summary>
            Parses a command line. This assumes that the exe name has been stripped off.
            Errors are output on Console.Error.
            Use ArgumentAttributes to control parsing behaviour.
            </summary>
            <param name="env"> The host environment</param>
            <param name="settings">The command line</param>
            <param name="destination">The object to receive the options</param>
            <returns>true if no errors were detected</returns>
        </member>
        <member name="M:Microsoft.ML.CommandLine.CmdParser.ParseArguments(Microsoft.ML.IHostEnvironment,System.String,System.Object,System.Type,Microsoft.ML.CommandLine.ErrorReporter)">
            <summary>
            Parses a command line. This assumes that the exe name has been stripped off.
            Use ArgumentAttributes to control parsing behaviour.
            </summary>
            <param name="env"> The host environment</param>
            <param name="settings">The command line</param>
            <param name="destination">The object to receive the options</param>
            <param name="destinationType">The type of 'destination'</param>
            <param name="reporter"> The destination for parse errors. </param>
            <returns>true if no errors were detected</returns>
        </member>
        <member name="M:Microsoft.ML.CommandLine.CmdParser.ParseArguments(Microsoft.ML.IHostEnvironment,System.String,System.Object,Microsoft.ML.CommandLine.ErrorReporter)">
            <summary>
            Parses a command line. This assumes that the exe name has been stripped off.
            Use ArgumentAttributes to control parsing behaviour.
            </summary>
            <param name="env"> The host environment</param>
            <param name="settings">The command line</param>
            <param name="destination">The object to receive the options</param>
            <param name="reporter"> The destination for parse errors. </param>
            <returns>true if no errors were detected</returns>
        </member>
        <member name="M:Microsoft.ML.CommandLine.CmdParser.IsNumericType(System.Type)">
            <summary>
            Check whether a certain type is numeric.
            </summary>
        </member>
        <member name="M:Microsoft.ML.CommandLine.CmdParser.ArgumentsUsage(Microsoft.ML.IHostEnvironment,System.Type,System.Object,System.Boolean,System.Nullable{System.Int32})">
            <summary>
            Returns a Usage string for command line argument parsing.
            Use ArgumentAttributes to control parsing behaviour.
            </summary>
            <param name="env"> The host environment. </param>
            <param name="type"> The type of the arguments to display usage for. </param>
            <param name="defaults"> The default values. </param>
            <param name="showRsp"> Whether to show the @file item. </param>
            <param name="columns"> The number of columns to format the output to. </param>
            <returns> Printable string containing a user friendly description of command line arguments. </returns>
        </member>
        <member name="M:Microsoft.ML.CommandLine.CmdParser.ParseArgumentList(Microsoft.ML.CommandLine.CmdParser.ArgumentInfo,System.String[],System.Object,Microsoft.ML.CommandLine.CmdParser.ArgValue[])">
            <summary>
            Parses an argument list into an object
            </summary>
            <param name="info"></param>
            <param name="strs"></param>
            <param name="destination"></param>
            <param name="values"></param>
            <returns> true if successful </returns>
        </member>
        <member name="M:Microsoft.ML.CommandLine.CmdParser.Parse(Microsoft.ML.CommandLine.CmdParser.ArgumentInfo,System.String[],System.Object)">
            <summary>
            Parses an argument list.
            </summary>
            <param name="info"></param>
            <param name="strs"> The arguments to parse. </param>
            <param name="destination"> The destination of the parsed arguments. </param>
            <returns> true if no parse errors were encountered. </returns>
        </member>
        <member name="M:Microsoft.ML.CommandLine.CmdParser.AppendCustomItem(Microsoft.ML.IHostEnvironment,Microsoft.ML.CommandLine.CmdParser.ArgumentInfo,System.Object,Microsoft.ML.CommandLine.SettingsFlags,System.Text.StringBuilder)">
            <summary>
            GetSettingsCore handles the top-level case. This handles the nested custom record case.
            It deals with custom "unparse" functionality, as well as quoting. It also appends to a StringBuilder
            instead of returning a string.
            </summary>
        </member>
        <member name="M:Microsoft.ML.CommandLine.CmdParser.GetUsageString(Microsoft.ML.IHostEnvironment,Microsoft.ML.CommandLine.CmdParser.ArgumentInfo,System.Boolean,System.Nullable{System.Int32})">
            <summary>
            A user friendly usage string describing the command line argument syntax.
            </summary>
        </member>
        <member name="M:Microsoft.ML.CommandLine.CmdParser.CreateComponentFactory(System.Type,System.Type,System.String)">
            <summary>
            Creates an ICommandLineComponentFactory given the factory type, signature type,
            and a command line string.
            </summary>
        </member>
        <member name="F:Microsoft.ML.CommandLine.CmdParser.ArgInfo.Arg._arg">
            <summary>
            This class exposes those parts of this wrapped <see cref="T:Microsoft.ML.CommandLine.CmdParser.Argument"/> appropriate
            for public consumption.
            </summary>
        </member>
        <member name="T:Microsoft.ML.CommandLine.CmdParser.ComponentFactoryFactory">
            <summary>
            A factory class for creating IComponentFactory instances.
            </summary>
        </member>
        <member name="T:Microsoft.ML.CommandLine.DefaultArgumentAttribute">
            <summary>
            Indicates that this argument is the default argument.
            '/' or '-' prefix only the argument value is specified.
            The ShortName property should not be set for DefaultArgumentAttribute
            instances. The LongName property is used for usage text only and
            does not affect the usage of the argument.
            </summary>
        </member>
        <member name="M:Microsoft.ML.CommandLine.DefaultArgumentAttribute.#ctor(Microsoft.ML.CommandLine.ArgumentType)">
            <summary>
            Indicates that this argument is the default argument.
            </summary>
            <param name="type"> Specifies the error checking to be done on the argument. </param>
        </member>
        <member name="T:Microsoft.ML.CommandLine.EnumValueDisplayAttribute">
            <summary>
            On an enum value - specifies the display name.
            </summary>
        </member>
        <member name="T:Microsoft.ML.CommandLine.HideEnumValueAttribute">
            <summary>
            On an enum value - indicates that the value should not be shown in help or UI.
            </summary>
        </member>
        <member name="F:Microsoft.ML.CommandLine.SpecialPurpose.ColumnSelector">
            <summary>
            This is used to specify a column mapping of a data transform.
            </summary>
        </member>
        <member name="F:Microsoft.ML.CommandLine.SpecialPurpose.MultilineText">
            <summary>
            This is meant to be a large text (like a c# code block, for example).
            </summary>
        </member>
        <member name="F:Microsoft.ML.CommandLine.SpecialPurpose.ColumnName">
            <summary>
            This is used to specify a column mapping of a data transform.
            </summary>
        </member>
        <member name="M:Microsoft.ML.AssemblyLoadingUtils.LoadAndRegister(Microsoft.ML.IHostEnvironment,System.String[])">
            <summary>
            Make sure the given assemblies are loaded and that their loadable classes have been catalogued.
            </summary>
        </member>
        <member name="M:Microsoft.ML.AssemblyLoadingUtils.LoadAssembly(Microsoft.ML.IHostEnvironment,System.String)">
            <summary>
            Given an assembly path, load the assembly and register it with the ComponentCatalog.
            </summary>
        </member>
        <member name="M:Microsoft.ML.AssemblyLoadingUtils.CanContainComponents(System.Reflection.Assembly)">
            <summary>
            Checks whether <paramref name="assembly"/> references the assembly containing LoadableClassAttributeBase,
            and therefore can contain components.
            </summary>
        </member>
        <member name="T:Microsoft.ML.ComponentCatalog">
            <summary>
            This catalogs instantiatable components (aka, loadable classes). Components are registered via
            a descendant of <see cref="T:Microsoft.ML.LoadableClassAttributeBase"/>, identifying the names and signature types under which the component
            type should be registered. Signatures are delegate types that return void and specify that parameter
            types for component instantiation. Each component may also specify an "arguments object" that should
            be provided at instantiation time.
            </summary>
        </member>
        <member name="T:Microsoft.ML.ComponentCatalog.LoadableClassInfo">
            <summary>
            Provides information on an instantiatable component, aka, loadable class.
            </summary>
        </member>
        <member name="T:Microsoft.ML.ComponentCatalog.LoadableClassInfo.Key">
            <summary>
            Used for dictionary lookup based on signature and name.
            </summary>
        </member>
        <member name="P:Microsoft.ML.ComponentCatalog.LoadableClassInfo.ExtraArgCount">
            <summary>
            Count of component construction arguments, NOT including the arguments object (if there is one).
            This matches the number of arguments for the signature type delegate(s).
            </summary>
        </member>
        <member name="P:Microsoft.ML.ComponentCatalog.LoadableClassInfo.LoaderType">
            <summary>
            The type that contains the construction method, whether static Instance property,
            static Create method, or constructor.
            </summary>
        </member>
        <member name="P:Microsoft.ML.ComponentCatalog.LoadableClassInfo.Summary">
            <summary>
            Summary of the component.
            </summary>
        </member>
        <member name="P:Microsoft.ML.ComponentCatalog.LoadableClassInfo.UserName">
            <summary>
            UserName may be null or empty, indicating that it should be hidden in UI.
            </summary>
        </member>
        <member name="P:Microsoft.ML.ComponentCatalog.LoadableClassInfo.IsHidden">
            <summary>
            Whether this is a "hidden" component, that generally shouldn't be displayed
            to users.
            </summary>
        </member>
        <member name="P:Microsoft.ML.ComponentCatalog.LoadableClassInfo.LoadNames">
            <summary>
            All load names. The first is the default.
            </summary>
        </member>
        <member name="P:Microsoft.ML.ComponentCatalog.LoadableClassInfo.InstanceGetter">
            <summary>
            The static property that returns an instance of this loadable class.
            This creation method does not support an arguments class.
            Only one of Ctor, Create and InstanceGetter can be non-null.
            </summary>
        </member>
        <member name="P:Microsoft.ML.ComponentCatalog.LoadableClassInfo.Constructor">
            <summary>
            The constructor to create an instance of this loadable class.
            This creation method supports an arguments class.
            Only one of Ctor, Create and InstanceGetter can be non-null.
            </summary>
        </member>
        <member name="P:Microsoft.ML.ComponentCatalog.LoadableClassInfo.CreateMethod">
            <summary>
            The static method that creates an instance of this loadable class.
            This creation method supports an arguments class.
            Only one of Ctor, Create and InstanceGetter can be non-null.
            </summary>
        </member>
        <member name="P:Microsoft.ML.ComponentCatalog.LoadableClassInfo.DocName">
            <summary>
            A name of an embedded resource containing documentation for this
            loadable class. This is non-null only in the event that we have
            verified the assembly of <see cref="P:Microsoft.ML.ComponentCatalog.LoadableClassInfo.LoaderType"/> actually contains
            this resource.
            </summary>
        </member>
        <member name="P:Microsoft.ML.ComponentCatalog.LoadableClassInfo.ArgType">
            <summary>
            The type that contains the arguments to the component.
            </summary>
        </member>
        <member name="M:Microsoft.ML.ComponentCatalog.LoadableClassInfo.CreateInstance(Microsoft.ML.IHostEnvironment,System.Object,System.Object[])">
            <summary>
            Create an instance, given the arguments object and arguments to the signature delegate.
            The args should be non-null iff ArgType is non-null. The length of the extra array should
            match the number of paramters for the signature delgate. When that number is zero, extra
            may be null.
            </summary>
        </member>
        <member name="M:Microsoft.ML.ComponentCatalog.LoadableClassInfo.CreateInstance``1(Microsoft.ML.IHostEnvironment,System.Object,System.Object[])">
            <summary>
            Create an instance, given the arguments object and arguments to the signature delegate.
            The args should be non-null iff ArgType is non-null. The length of the extra array should
            match the number of paramters for the signature delgate. When that number is zero, extra
            may be null.
            </summary>
        </member>
        <member name="M:Microsoft.ML.ComponentCatalog.LoadableClassInfo.CreateInstance``1(Microsoft.ML.IHostEnvironment)">
            <summary>
            Create an instance with default arguments.
            </summary>
        </member>
        <member name="M:Microsoft.ML.ComponentCatalog.LoadableClassInfo.CreateArguments">
            <summary>
            If <see cref="P:Microsoft.ML.ComponentCatalog.LoadableClassInfo.ArgType"/> is not null, returns a new default instance of <see cref="P:Microsoft.ML.ComponentCatalog.LoadableClassInfo.ArgType"/>.
            Otherwise, returns null.
            </summary>
        </member>
        <member name="T:Microsoft.ML.ComponentCatalog.EntryPointInfo">
            <summary>
            A description of a single entry point.
            </summary>
        </member>
        <member name="T:Microsoft.ML.ComponentCatalog.ComponentInfo">
            <summary>
            A description of a single component.
            The 'component' is a non-standalone building block that is used to parametrize entry points or other ML.NET components.
            For example, 'Loss function', or 'similarity calculator' could be components.
            </summary>
        </member>
        <member name="M:Microsoft.ML.ComponentCatalog.RegisterAssembly(System.Reflection.Assembly,System.Boolean)">
            <summary>
            Registers all the components in the specified assembly by looking for loadable classes
            and adding them to the catalog.
            </summary>
            <param name="assembly">
            The assembly to register.
            </param>
            <param name="throwOnError">
            true to throw an exception if there are errors with registering the components;
            false to skip any errors.
            </param>
        </member>
        <member name="M:Microsoft.ML.ComponentCatalog.GetAllClasses">
            <summary>
            Return an array containing information for all instantiatable components.
            If provided, the given set of assemblies is loaded first.
            </summary>
        </member>
        <member name="M:Microsoft.ML.ComponentCatalog.GetAllDerivedClasses(System.Type,System.Type)">
            <summary>
            Return an array containing information for instantiatable components with the given
            signature and base type. If provided, the given set of assemblies is loaded first.
            </summary>
        </member>
        <member name="M:Microsoft.ML.ComponentCatalog.GetAllSignatureTypes">
            <summary>
            Return an array containing all the known signature types. If provided, the given set of assemblies
            is loaded first.
            </summary>
        </member>
        <member name="M:Microsoft.ML.ComponentCatalog.SignatureToString(System.Type)">
            <summary>
            Returns a string name for a given signature type.
            </summary>
        </member>
        <member name="M:Microsoft.ML.ComponentCatalog.AllEntryPoints">
            <summary>
            Get all registered entry points.
            </summary>
        </member>
        <member name="M:Microsoft.ML.ComponentCatalog.TryFindComponentCaseInsensitive(System.Type,System.String,Microsoft.ML.ComponentCatalog.ComponentInfo@)">
            <summary>
            Akin to <see cref="M:Microsoft.ML.ComponentCatalog.TryFindComponent(System.Type,System.String,Microsoft.ML.ComponentCatalog.ComponentInfo@)"/>, except if the regular (case sensitive) comparison fails, it will
            attempt to back off to a case-insensitive comparison.
            </summary>
        </member>
        <member name="M:Microsoft.ML.ComponentCatalog.GetAllComponentKinds">
            <summary>
            Returns all valid component kinds.
            </summary>
        </member>
        <member name="M:Microsoft.ML.ComponentCatalog.GetAllComponents(System.String)">
            <summary>
            Returns all components of the specified kind.
            </summary>
        </member>
        <member name="M:Microsoft.ML.ComponentCatalog.GetAllComponents(System.Type)">
            <summary>
            Returns all components that implement the specified interface.
            </summary>
        </member>
        <member name="F:Microsoft.ML.ComponentCatalog._nameRegex">
            <summary>
            The valid names for the components and entry points must consist of letters, digits, underscores and dots,
            and begin with a letter or digit.
            </summary>
        </member>
        <member name="M:Microsoft.ML.ComponentCatalog.CreateInstance``1(Microsoft.ML.IHostEnvironment,System.Type,System.String,System.String,System.Object[])">
            <summary>
            Create an instance of the indicated component with the given extra parameters.
            </summary>
        </member>
        <member name="M:Microsoft.ML.ComponentCatalog.TryCreateInstance``2(Microsoft.ML.IHostEnvironment,``0@,System.String,System.String,System.Object[])">
            <summary>
            Try to create an instance of the indicated component and settings with the given extra parameters.
            If there is no such component in the catalog, returns false. Any other error results in an exception.
            </summary>
        </member>
        <member name="M:Microsoft.ML.ComponentCatalog.ParseArguments(Microsoft.ML.IHostEnvironment,System.Object,System.String,System.String)">
            <summary>
            Parses arguments using CmdParser. If there's a problem, it throws an InvalidOperationException,
            with a message giving usage.
            </summary>
            <param name="env">The host environment</param>
            <param name="args">The argument object</param>
            <param name="settings">The settings string</param>
            <param name="name">The name is used for error reporting only</param>
        </member>
        <member name="M:Microsoft.ML.ComponentCatalog.CanContainExtensions(System.Reflection.Assembly)">
            <summary>
            Gets a value indicating whether <paramref name="assembly"/> can contain extensions.
            </summary>
            <remarks>
            All ML.NET product assemblies won't contain extensions.
            </remarks>
        </member>
        <member name="T:Microsoft.ML.IComponentFactory">
            <summary>
            This is a token interface that all component factories must implement.
            </summary>
        </member>
        <member name="T:Microsoft.ML.IComponentFactory`1">
            <summary>
            An interface for creating a component with no extra parameters (other than an <see cref="T:Microsoft.ML.IHostEnvironment"/>).
            </summary>
        </member>
        <member name="T:Microsoft.ML.IComponentFactory`2">
            <summary>
            An interface for creating a component when we take one extra parameter (and an <see cref="T:Microsoft.ML.IHostEnvironment"/>).
            </summary>
        </member>
        <member name="T:Microsoft.ML.IComponentFactory`3">
            <summary>
            An interface for creating a component when we take two extra parameters (and an <see cref="T:Microsoft.ML.IHostEnvironment"/>).
            </summary>
        </member>
        <member name="T:Microsoft.ML.IComponentFactory`4">
            <summary>
            An interface for creating a component when we take three extra parameters (and an <see cref="T:Microsoft.ML.IHostEnvironment"/>).
            </summary>
        </member>
        <member name="T:Microsoft.ML.ComponentFactoryUtils">
            <summary>
            A utility class for creating <see cref="T:Microsoft.ML.IComponentFactory"/> instances.
            </summary>
        </member>
        <member name="M:Microsoft.ML.ComponentFactoryUtils.CreateFromFunction``1(System.Func{Microsoft.ML.IHostEnvironment,``0})">
            <summary>
            Creates a component factory with no extra parameters (other than an <see cref="T:Microsoft.ML.IHostEnvironment"/>)
            that simply wraps a delegate which creates the component.
            </summary>
        </member>
        <member name="M:Microsoft.ML.ComponentFactoryUtils.CreateFromFunction``2(System.Func{Microsoft.ML.IHostEnvironment,``0,``1})">
            <summary>
            Creates a component factory when we take one extra parameter (and an
            <see cref="T:Microsoft.ML.IHostEnvironment"/>) that simply wraps a delegate which creates the component.
            </summary>
        </member>
        <member name="M:Microsoft.ML.ComponentFactoryUtils.CreateFromFunction``3(System.Func{Microsoft.ML.IHostEnvironment,``0,``1,``2})">
            <summary>
            Creates a component factory when we take two extra parameters (and an
            <see cref="T:Microsoft.ML.IHostEnvironment"/>) that simply wraps a delegate which creates the component.
            </summary>
        </member>
        <member name="M:Microsoft.ML.ComponentFactoryUtils.CreateFromFunction``4(System.Func{Microsoft.ML.IHostEnvironment,``0,``1,``2,``3})">
            <summary>
            Creates a component factory when we take three extra parameters (and an
            <see cref="T:Microsoft.ML.IHostEnvironment"/>) that simply wraps a delegate which creates the component.
            </summary>
        </member>
        <member name="T:Microsoft.ML.ComponentFactoryUtils.SimpleComponentFactory`1">
            <summary>
            A class for creating a component with no extra parameters (other than an <see cref="T:Microsoft.ML.IHostEnvironment"/>)
            that simply wraps a delegate which creates the component.
            </summary>
        </member>
        <member name="T:Microsoft.ML.ComponentFactoryUtils.SimpleComponentFactory`2">
            <summary>
            A class for creating a component when we take one extra parameter
            (and an <see cref="T:Microsoft.ML.IHostEnvironment"/>) that simply wraps a delegate which
            creates the component.
            </summary>
        </member>
        <member name="T:Microsoft.ML.ComponentFactoryUtils.SimpleComponentFactory`3">
            <summary>
            A class for creating a component when we take one extra parameter
            (and an <see cref="T:Microsoft.ML.IHostEnvironment"/>) that simply wraps a delegate which
            creates the component.
            </summary>
        </member>
        <member name="T:Microsoft.ML.ComponentFactoryUtils.SimpleComponentFactory`4">
            <summary>
            A class for creating a component when we take three extra parameters
            (and an <see cref="T:Microsoft.ML.IHostEnvironment"/>) that simply wraps a delegate which
            creates the component.
            </summary>
        </member>
        <member name="T:Microsoft.ML.ExtensionBaseAttribute">
            <summary>
            The base attribute type for all attributes used for extensibility purposes.
            </summary>
        </member>
        <member name="T:Microsoft.ML.SignatureDefault">
            <summary>
            Common signature type with no extra parameters.
            </summary>
        </member>
        <member name="M:Microsoft.ML.LoadableClassAttribute.#ctor(System.Type,System.Type,System.Type,System.String,System.String[])">
            <summary>
            Assembly attribute used to specify that a class is loadable by a machine learning
            host environment, such as TLC
            </summary>
            <param name="instType">The class type that is loadable</param>
            <param name="argType">The argument type that the constructor takes (may be null)</param>
            <param name="sigType">The signature of the constructor of this class (in addition to the arguments parameter)</param>
            <param name="userName">The name to use when presenting a list to users</param>
            <param name="loadNames">The names that can be used to load the class, for example, from a command line</param>
        </member>
        <member name="M:Microsoft.ML.LoadableClassAttribute.#ctor(System.Type,System.Type,System.Type,System.Type,System.String,System.String[])">
            <summary>
            Assembly attribute used to specify that a class is loadable by a machine learning
            host environment, such as TLC
            </summary>
            <param name="instType">The class type that is loadable</param>
            <param name="loaderType">The class type that contains the construction method</param>
            <param name="argType">The argument type that the constructor takes (may be null)</param>
            <param name="sigType">The signature of the constructor of this class (in addition to the arguments parameter)</param>
            <param name="userName">The name to use when presenting a list to users</param>
            <param name="loadNames">The names that can be used to load the class, for example, from a command line</param>
        </member>
        <member name="M:Microsoft.ML.LoadableClassAttribute.#ctor(System.String,System.Type,System.Type,System.Type,System.String,System.String[])">
            <summary>
            Assembly attribute used to specify that a class is loadable by a machine learning
            host environment, such as TLC
            </summary>
            <param name="summary">The description summary of the class type</param>
            <param name="instType">The class type that is loadable</param>
            <param name="argType">The argument type that the constructor takes (may be null)</param>
            <param name="sigType">The signature of the constructor of this class (in addition to the arguments parameter)</param>
            <param name="userName">The name to use when presenting a list to users</param>
            <param name="loadNames">The names that can be used to load the class, for example, from a command line</param>
        </member>
        <member name="M:Microsoft.ML.LoadableClassAttribute.#ctor(System.String,System.Type,System.Type,System.Type,System.Type,System.String,System.String[])">
            <summary>
            Assembly attribute used to specify that a class is loadable by a machine learning
            host environment, such as TLC
            </summary>
            <param name="summary">The description summary of the class type</param>
            <param name="instType">The class type that is loadable</param>
            <param name="loaderType">The class type that contains the construction method</param>
            <param name="argType">The argument type that the constructor takes (may be null)</param>
            <param name="sigType">The signature of the constructor of this class (in addition to the arguments parameter)</param>
            <param name="userName">The name to use when presenting a list to users</param>
            <param name="loadNames">The names that can be used to load the class, for example, from a command line</param>
        </member>
        <member name="P:Microsoft.ML.LoadableClassAttributeBase.InstanceType">
            <summary>
            The type that is created/loaded.
            </summary>
        </member>
        <member name="P:Microsoft.ML.LoadableClassAttributeBase.LoaderType">
            <summary>
            The type that contains the construction method, whether static Instance property,
            static Create method, or constructor. Of course, a constructor is only permissible if
            this type derives from InstanceType. This defaults to the same as InstanceType.
            </summary>
        </member>
        <member name="P:Microsoft.ML.LoadableClassAttributeBase.ArgType">
            <summary>
            The command line arguments object type. This should be null if there isn't one.
            </summary>
        </member>
        <member name="P:Microsoft.ML.LoadableClassAttributeBase.SigTypes">
            <summary>
            This indicates the extra parameter types. It must be a delegate type. The return type should be void.
            The parameter types of the SigType delegate should NOT include the ArgType.
            </summary>
        </member>
        <member name="P:Microsoft.ML.LoadableClassAttributeBase.CtorTypes">
            <summary>
            Note that CtorTypes includes the ArgType (if there is one), and the parameter types of the SigType.
            </summary>
        </member>
        <member name="P:Microsoft.ML.LoadableClassAttributeBase.Summary">
            <summary>
            The description summary of the class type.
            </summary>
        </member>
        <member name="P:Microsoft.ML.LoadableClassAttributeBase.UserName">
            <summary>
            UserName may be null or empty indicating that it should be hidden in UI.
            </summary>
        </member>
        <member name="P:Microsoft.ML.LoadableClassAttributeBase.DocName">
            <summary>
            This should indicate a path within the <code>doc/public</code> directory next to the TLC
            solution, where the documentation lies. This value will be used as part of a URL, so,
            the path separator should be phrased as '/' forward slashes rather than backslashes.</summary>
        </member>
        <member name="M:Microsoft.ML.Data.AnnotationBuilderExtensions.AddSlotNames(Microsoft.Data.DataView.DataViewSchema.Annotations.Builder,System.Int32,Microsoft.Data.DataView.ValueGetter{Microsoft.ML.Data.VBuffer{System.ReadOnlyMemory{System.Char}}})">
            <summary>
            Add slot names annotation.
            </summary>
            <param name="builder">The <see cref="T:Microsoft.Data.DataView.DataViewSchema.Annotations.Builder"/> to which to add the slot names.</param>
            <param name="size">The size of the slot names vector.</param>
            <param name="getter">The getter delegate for the slot names.</param>
        </member>
        <member name="M:Microsoft.ML.Data.AnnotationBuilderExtensions.AddKeyValues``1(Microsoft.Data.DataView.DataViewSchema.Annotations.Builder,System.Int32,Microsoft.Data.DataView.PrimitiveDataViewType,Microsoft.Data.DataView.ValueGetter{Microsoft.ML.Data.VBuffer{``0}})">
            <summary>
            Add key values annotation.
            </summary>
            <typeparam name="TValue">The value type of key values.</typeparam>
            <param name="builder">The <see cref="T:Microsoft.Data.DataView.DataViewSchema.Annotations.Builder"/> to which to add the key values.</param>
            <param name="size">The size of key values vector.</param>
            <param name="valueType">The value type of key values. Its raw type must match <typeparamref name="TValue"/>.</param>
            <param name="getter">The getter delegate for the key values.</param>
        </member>
        <member name="T:Microsoft.ML.Data.AnnotationUtils">
            <summary>
            Utilities for implementing and using the annotation API of <see cref="T:Microsoft.Data.DataView.DataViewSchema"/>.
            </summary>
        </member>
        <member name="T:Microsoft.ML.Data.AnnotationUtils.Kinds">
            <summary>
            This class lists the canonical annotation kinds
            </summary>
        </member>
        <member name="F:Microsoft.ML.Data.AnnotationUtils.Kinds.SlotNames">
            <summary>
            Annotation kind for names associated with slots/positions in a vector-valued column.
            The associated annotation type is typically fixed-sized vector of Text.
            </summary>
        </member>
        <member name="F:Microsoft.ML.Data.AnnotationUtils.Kinds.KeyValues">
            <summary>
            Annotation kind for values associated with the key indices when the column type's item type
            is a key type. The associated annotation type is typically fixed-sized vector of a primitive
            type. The primitive type is frequently Text, but can be anything.
            </summary>
        </member>
        <member name="F:Microsoft.ML.Data.AnnotationUtils.Kinds.ScoreColumnSetId">
            <summary>
            Annotation kind for sets of score columns. The value is typically a KeyType with raw type U4.
            </summary>
        </member>
        <member name="F:Microsoft.ML.Data.AnnotationUtils.Kinds.ScoreColumnKind">
            <summary>
            Annotation kind that indicates the prediction kind as a string. For example, "BinaryClassification".
            The value is typically a ReadOnlyMemory&lt;char&gt;.
            </summary>
        </member>
        <member name="F:Microsoft.ML.Data.AnnotationUtils.Kinds.ScoreValueKind">
            <summary>
            Annotation kind that indicates the value kind of the score column as a string. For example, "Score", "PredictedLabel", "Probability". The value is typically a ReadOnlyMemory.
            </summary>
        </member>
        <member name="F:Microsoft.ML.Data.AnnotationUtils.Kinds.IsNormalized">
            <summary>
            Annotation kind that indicates if a column is normalized. The value is typically a Bool.
            </summary>
        </member>
        <member name="F:Microsoft.ML.Data.AnnotationUtils.Kinds.IsUserVisible">
            <summary>
            Annotation kind that indicates if a column is visible to the users. The value is typically a Bool.
            Not to be confused with IsHidden() that determines if a column is masked.
            </summary>
        </member>
        <member name="F:Microsoft.ML.Data.AnnotationUtils.Kinds.TrainingLabelValues">
            <summary>
            Annotation kind for the label values used in training to be used for the predicted label.
            The value is typically a fixed-sized vector of Text.
            </summary>
        </member>
        <member name="F:Microsoft.ML.Data.AnnotationUtils.Kinds.CategoricalSlotRanges">
            <summary>
            Annotation kind that indicates the ranges within a column that are categorical features.
            The value is a vector type of ints with dimension of two. The first dimension
            represents the number of categorical features and second dimension represents the range
            and is of size two. The range has start and end index(both inclusive) of categorical
            slots within that column.
            </summary>
        </member>
        <member name="T:Microsoft.ML.Data.AnnotationUtils.Const">
            <summary>
            This class holds all pre-defined string values that can be found in canonical annotations
            </summary>
        </member>
        <member name="T:Microsoft.ML.Data.AnnotationUtils.AnnotationGetter`1">
            <summary>
            Helper delegate for marshaling from generic land to specific types. Used by the Marshal method below.
            </summary>
        </member>
        <member name="M:Microsoft.ML.Data.AnnotationUtils.ExceptGetAnnotation">
            <summary>
            Returns a standard exception for responding to an invalid call to GetAnnotation.
            </summary>
        </member>
        <member name="M:Microsoft.ML.Data.AnnotationUtils.ExceptGetAnnotation(Microsoft.ML.IExceptionContext)">
            <summary>
            Returns a standard exception for responding to an invalid call to GetAnnotation.
            </summary>
        </member>
        <member name="M:Microsoft.ML.Data.AnnotationUtils.Marshal``2(Microsoft.ML.Data.AnnotationUtils.AnnotationGetter{``0},System.Int32,``1@)">
            <summary>
            Helper to marshal a call to GetAnnotation{TValue} to a specific type.
            </summary>
        </member>
        <member name="M:Microsoft.ML.Data.AnnotationUtils.GetNamesType(System.Int32)">
            <summary>
            Returns a vector type with item type text and the given size. The size must be positive.
            This is a standard type for annotation consisting of multiple text values, eg SlotNames.
            </summary>
        </member>
        <member name="M:Microsoft.ML.Data.AnnotationUtils.GetCategoricalType(System.Int32)">
            <summary>
            Returns a vector type with item type int and the given size.
            The range count must be a positive integer.
            This is a standard type for annotation consisting of multiple int values that represent
            categorical slot ranges with in a column.
            </summary>
        </member>
        <member name="P:Microsoft.ML.Data.AnnotationUtils.ScoreColumnSetIdType">
            <summary>
            The type of the ScoreColumnSetId annotation.
            </summary>
        </member>
        <member name="M:Microsoft.ML.Data.AnnotationUtils.GetSlotNamesPair(System.Int32)">
            <summary>
            Returns a key-value pair useful when implementing GetAnnotationTypes(col).
            </summary>
        </member>
        <member name="M:Microsoft.ML.Data.AnnotationUtils.GetKeyNamesPair(System.Int32)">
            <summary>
            Returns a key-value pair useful when implementing GetAnnotationTypes(col). This assumes
            that the values of the key type are Text.
            </summary>
        </member>
        <member name="M:Microsoft.ML.Data.AnnotationUtils.GetPair(Microsoft.Data.DataView.DataViewType,System.String)">
            <summary>
            Given a type and annotation kind string, returns a key-value pair. This is useful when
            implementing GetAnnotationTypes(col).
            </summary>
        </member>
        <member name="M:Microsoft.ML.Data.AnnotationUtils.Prepend``1(System.Collections.Generic.IEnumerable{``0},``0[])">
            <summary>
            Prepends a params array to an enumerable. Useful when implementing GetAnnotationTypes.
            </summary>
        </member>
        <member name="M:Microsoft.ML.Data.AnnotationUtils.GetMaxAnnotationKind(Microsoft.Data.DataView.DataViewSchema,System.Int32@,System.String,System.Func{Microsoft.Data.DataView.DataViewSchema,System.Int32,System.Boolean})">
            <summary>
            Returns the max value for the specified annotation kind.
            The annotation type should be a KeyType with raw type U4.
            colMax will be set to the first column that has the max value for the specified annotation.
            If no column has the specified annotation, colMax is set to -1 and the method returns zero.
            The filter function is called for each column, passing in the schema and the column index, and returns
            true if the column should be considered, false if the column should be skipped.
            </summary>
        </member>
        <member name="M:Microsoft.ML.Data.AnnotationUtils.GetColumnSet(Microsoft.Data.DataView.DataViewSchema,System.String,System.UInt32)">
            <summary>
            Returns the set of column ids which match the value of specified annotation kind.
            The annotation type should be a KeyType with raw type U4.
            </summary>
        </member>
        <member name="M:Microsoft.ML.Data.AnnotationUtils.GetColumnSet(Microsoft.Data.DataView.DataViewSchema,System.String,System.String)">
            <summary>
            Returns the set of column ids which match the value of specified annotation kind.
            The annotation type should be of type text.
            </summary>
        </member>
        <member name="M:Microsoft.ML.Data.AnnotationUtils.HasSlotNames(Microsoft.Data.DataView.DataViewSchema.Column,System.Int32)">
            <summary>
            Returns <c>true</c> if the specified column:
             * has a SlotNames annotation
             * annotation type is VBuffer&lt;ReadOnlyMemory&lt;char&gt;&gt; of length <paramref name="vectorSize"/>.
            </summary>
        </member>
        <member name="M:Microsoft.ML.Data.AnnotationUtils.IsNormalized(Microsoft.ML.SchemaShape.Column)">
            <summary>
            Returns whether a column has the <see cref="F:Microsoft.ML.Data.AnnotationUtils.Kinds.IsNormalized"/> annotation indicated by
            the schema shape.
            </summary>
            <param name="column">The schema shape column to query</param>
            <returns>True if and only if the column has the <see cref="F:Microsoft.ML.Data.AnnotationUtils.Kinds.IsNormalized"/> annotation
            of a scalar <see cref="T:Microsoft.Data.DataView.BooleanDataViewType"/> type, which we assume, if set, should be <c>true</c>.</returns>
        </member>
        <member name="M:Microsoft.ML.Data.AnnotationUtils.HasSlotNames(Microsoft.ML.SchemaShape.Column)">
            <summary>
            Returns whether a column has the <see cref="F:Microsoft.ML.Data.AnnotationUtils.Kinds.SlotNames"/> annotation indicated by
            the schema shape.
            </summary>
            <param name="col">The schema shape column to query</param>
            <returns>True if and only if the column is a definite sized vector type, has the
            <see cref="F:Microsoft.ML.Data.AnnotationUtils.Kinds.SlotNames"/> annotation of definite sized vectors of text.</returns>
        </member>
        <member name="M:Microsoft.ML.Data.AnnotationUtils.TryGetAnnotation``1(Microsoft.Data.DataView.DataViewSchema,Microsoft.Data.DataView.PrimitiveDataViewType,System.String,System.Int32,``0@)">
            <summary>
            Tries to get the annotation kind of the specified type for a column.
            </summary>
            <typeparam name="T">The raw type of the annotation, should match the PrimitiveType type</typeparam>
            <param name="schema">The schema</param>
            <param name="type">The type of the annotation</param>
            <param name="kind">The annotation kind</param>
            <param name="col">The column</param>
            <param name="value">The value to return, if successful</param>
            <returns>True if the annotation of the right type exists, false otherwise</returns>
        </member>
        <member name="M:Microsoft.ML.Data.AnnotationUtils.TryGetCategoricalFeatureIndices(Microsoft.Data.DataView.DataViewSchema,System.Int32,System.Int32[]@)">
            <summary>
            The categoricalFeatures is a vector of the indices of categorical features slots.
            This vector should always have an even number of elements, and the elements should be parsed in groups of two consecutive numbers.
            So if its value is the range of numbers: 0,2,3,4,8,9
            look at it as [0,2],[3,4],[8,9].
            The way to interpret that is: feature with indices 0, 1, and 2 are one categorical
            Features with indices 3 and 4 are another categorical. Features 5 and 6 don't appear there, so they are not categoricals.
            </summary>
        </member>
        <member name="M:Microsoft.ML.Data.AnnotationUtils.GetTrainerOutputAnnotation(System.Boolean)">
            <summary>
            Produces sequence of columns that are generated by trainer estimators.
            </summary>
            <param name="isNormalized">whether we should also append 'IsNormalized' (typically for probability column)</param>
        </member>
        <member name="M:Microsoft.ML.Data.AnnotationUtils.AnnotationsForMulticlassScoreColumn(System.Nullable{Microsoft.ML.SchemaShape.Column})">
            <summary>
            Produces annotations for the score column generated by trainer estimators for multiclass classification.
            If input LabelColumn is not available it produces slotnames annotation by default.
            </summary>
            <param name="labelColumn">Label column.</param>
        </member>
        <member name="M:Microsoft.ML.Data.AnnotationUtils.AnnotationsAsRow(Microsoft.Data.DataView.DataViewSchema.Annotations)">
            <summary>
            Presents a <see cref="T:Microsoft.Data.DataView.DataViewSchema.Annotations"/> as a an <see cref="T:Microsoft.Data.DataView.DataViewRow"/>.
            </summary>
            <param name="annotations">The annotations to wrap.</param>
            <returns>A row that wraps an input annotations.</returns>
        </member>
        <member name="T:Microsoft.ML.Data.ColumnTypeExtensions">
            <summary>
            Extension methods related to the ColumnType class.
            </summary>
        </member>
        <member name="M:Microsoft.ML.Data.ColumnTypeExtensions.IsStandardScalar(Microsoft.Data.DataView.DataViewType)">
            <summary>
            Whether this type is a standard scalar type completely determined by its <see cref="P:Microsoft.Data.DataView.DataViewType.RawType"/>
            (not a <see cref="T:Microsoft.ML.Data.KeyType"/> or <see cref="T:Microsoft.Data.DataView.StructuredDataViewType"/>, etc).
            </summary>
        </member>
        <member name="M:Microsoft.ML.Data.ColumnTypeExtensions.GetKeyCount(Microsoft.Data.DataView.DataViewType)">
            <summary>
            Zero return means it's not a key type.
            </summary>
        </member>
        <member name="M:Microsoft.ML.Data.ColumnTypeExtensions.GetKeyCountAsInt32(Microsoft.Data.DataView.DataViewType,Microsoft.ML.IExceptionContext)">
            <summary>
            Sometimes it is necessary to cast the Count to an int. This performs overflow check.
            Zero return means it's not a key type.
            </summary>
        </member>
        <member name="M:Microsoft.ML.Data.ColumnTypeExtensions.GetItemType(Microsoft.Data.DataView.DataViewType)">
            <summary>
            For non-vector types, this returns the column type itself (i.e., return <paramref name="columnType"/>).
            For vector types, this returns the type of the items stored as values in vector.
            </summary>
        </member>
        <member name="M:Microsoft.ML.Data.ColumnTypeExtensions.GetVectorSize(Microsoft.Data.DataView.DataViewType)">
            <summary>
            Zero return means either it's not a vector or the size is unknown.
            </summary>
        </member>
        <member name="M:Microsoft.ML.Data.ColumnTypeExtensions.GetValueCount(Microsoft.Data.DataView.DataViewType)">
            <summary>
            For non-vectors, this returns one. For unknown size vectors, it returns zero.
            For known sized vectors, it returns size.
            </summary>
        </member>
        <member name="M:Microsoft.ML.Data.ColumnTypeExtensions.IsKnownSizeVector(Microsoft.Data.DataView.DataViewType)">
            <summary>
            Whether this is a vector type with known size. Returns false for non-vector types.
            Equivalent to <c><see cref="M:Microsoft.ML.Data.ColumnTypeExtensions.GetVectorSize(Microsoft.Data.DataView.DataViewType)"/> &gt; 0</c>.
            </summary>
        </member>
        <member name="M:Microsoft.ML.Data.ColumnTypeExtensions.GetRawKind(Microsoft.Data.DataView.DataViewType)">
            <summary>
            Gets the equivalent <see cref="T:Microsoft.ML.Data.InternalDataKind"/> for the <paramref name="columnType"/>'s RawType.
            This can return default(<see cref="T:Microsoft.ML.Data.InternalDataKind"/>) if the RawType doesn't have a corresponding
            <see cref="T:Microsoft.ML.Data.InternalDataKind"/>.
            </summary>
        </member>
        <member name="M:Microsoft.ML.Data.ColumnTypeExtensions.SameSizeAndItemType(Microsoft.Data.DataView.DataViewType,Microsoft.Data.DataView.DataViewType)">
            <summary>
            Equivalent to calling Equals(ColumnType) for non-vector types. For vector type,
            returns true if current and other vector types have the same size and item type.
            </summary>
        </member>
        <member name="T:Microsoft.ML.Data.DataKind">
            <summary>
            Specifies a simple data type.
            </summary>
        </member>
        <member name="F:Microsoft.ML.Data.DataKind.SByte">
            <summary>1-byte integer, type of <see cref="T:System.SByte"/>.</summary>
        </member>
        <member name="F:Microsoft.ML.Data.DataKind.Byte">
            <summary>1-byte unsigned integer, type of <see cref="T:System.Byte"/>.</summary>
        </member>
        <member name="F:Microsoft.ML.Data.DataKind.Int16">
            <summary>2-byte integer, type of <see cref="T:System.Int16"/>.</summary>
        </member>
        <member name="F:Microsoft.ML.Data.DataKind.UInt16">
            <summary>2-byte usigned integer, type of <see cref="T:System.UInt16"/>.</summary>
        </member>
        <member name="F:Microsoft.ML.Data.DataKind.Int32">
            <summary>4-byte integer, type of <see cref="T:System.Int32"/>.</summary>
        </member>
        <member name="F:Microsoft.ML.Data.DataKind.UInt32">
            <summary>4-byte usigned integer, type of <see cref="T:System.UInt32"/>.</summary>
        </member>
        <member name="F:Microsoft.ML.Data.DataKind.Int64">
            <summary>8-byte integer, type of <see cref="T:System.Int64"/>.</summary>
        </member>
        <member name="F:Microsoft.ML.Data.DataKind.UInt64">
            <summary>8-byte usigned integer, type of <see cref="T:System.UInt64"/>.</summary>
        </member>
        <member name="F:Microsoft.ML.Data.DataKind.Single">
            <summary>4-byte floating-point number, type of <see cref="T:System.Single"/>.</summary>
        </member>
        <member name="F:Microsoft.ML.Data.DataKind.Double">
            <summary>8-byte floating-point number, type of <see cref="T:System.Double"/>.</summary>
        </member>
        <member name="F:Microsoft.ML.Data.DataKind.String">
            <summary>string, type of <see cref="T:System.String"/>.</summary>
        </member>
        <member name="F:Microsoft.ML.Data.DataKind.Boolean">
            <summary>boolean variable type, type of <see cref="T:System.Boolean"/>.</summary>
        </member>
        <member name="F:Microsoft.ML.Data.DataKind.TimeSpan">
            <summary>type of <see cref="T:System.TimeSpan"/>.</summary>
        </member>
        <member name="F:Microsoft.ML.Data.DataKind.DateTime">
            <summary>type of <see cref="T:System.DateTime"/>.</summary>
        </member>
        <member name="F:Microsoft.ML.Data.DataKind.DateTimeOffset">
            <summary>type of <see cref="T:System.DateTimeOffset"/>.</summary>
        </member>
        <member name="T:Microsoft.ML.Data.InternalDataKind">
            <summary>
            Data type specifier used in command line. <see cref="T:Microsoft.ML.Data.InternalDataKind"/> is the underlying version of <see cref="T:Microsoft.ML.Data.DataKind"/>
            used for command line and entry point BC.
            </summary>
        </member>
        <member name="T:Microsoft.ML.Data.InternalDataKindExtensions">
            <summary>
            Extension methods related to the DataKind enum.
            </summary>
        </member>
        <member name="M:Microsoft.ML.Data.InternalDataKindExtensions.ToIndex(Microsoft.ML.Data.InternalDataKind)">
            <summary>
            Maps a DataKind to a value suitable for indexing into an array of size KindCount.
            </summary>
        </member>
        <member name="M:Microsoft.ML.Data.InternalDataKindExtensions.FromIndex(System.Int32)">
            <summary>
            Maps from an index into an array of size KindCount to the corresponding DataKind
            </summary>
        </member>
        <member name="M:Microsoft.ML.Data.InternalDataKindExtensions.ToInternalDataKind(Microsoft.ML.Data.DataKind)">
            <summary>
            This function converts <paramref name="dataKind"/> to <see cref="T:Microsoft.ML.Data.InternalDataKind"/>.
            Because <see cref="T:Microsoft.ML.Data.DataKind"/> is a subset of <see cref="T:Microsoft.ML.Data.InternalDataKind"/>, the conversion is straightforward.
            </summary>
        </member>
        <member name="M:Microsoft.ML.Data.InternalDataKindExtensions.ToDataKind(Microsoft.ML.Data.InternalDataKind)">
            <summary>
            This function converts <paramref name="kind"/> to <see cref="T:Microsoft.ML.Data.DataKind"/>.
            Because <see cref="T:Microsoft.ML.Data.DataKind"/> is a subset of <see cref="T:Microsoft.ML.Data.InternalDataKind"/>, we should check if <paramref name="kind"/>
            can be found in <see cref="T:Microsoft.ML.Data.DataKind"/>.
            </summary>
        </member>
        <member name="M:Microsoft.ML.Data.InternalDataKindExtensions.ToMaxInt(Microsoft.ML.Data.InternalDataKind)">
            <summary>
            For integer DataKinds, this returns the maximum legal value. For un-supported kinds,
            it returns zero.
            </summary>
        </member>
        <member name="M:Microsoft.ML.Data.InternalDataKindExtensions.ToMaxInt(System.Type)">
            <summary>
            For integer Types, this returns the maximum legal value. For un-supported Types,
            it returns zero.
            </summary>
        </member>
        <member name="M:Microsoft.ML.Data.InternalDataKindExtensions.ToMinInt(Microsoft.ML.Data.InternalDataKind)">
            <summary>
            For integer DataKinds, this returns the minimum legal value. For un-supported kinds,
            it returns one.
            </summary>
        </member>
        <member name="M:Microsoft.ML.Data.InternalDataKindExtensions.ToType(Microsoft.ML.Data.InternalDataKind)">
            <summary>
            Maps a DataKind to the associated .Net representation type.
            </summary>
        </member>
        <member name="M:Microsoft.ML.Data.InternalDataKindExtensions.TryGetDataKind(System.Type,Microsoft.ML.Data.InternalDataKind@)">
            <summary>
            Try to map a System.Type to a corresponding DataKind value.
            </summary>
        </member>
        <member name="M:Microsoft.ML.Data.InternalDataKindExtensions.GetString(Microsoft.ML.Data.InternalDataKind)">
            <summary>
            Get the canonical string for a DataKind. Note that using DataKind.ToString() is not stable
            and is also slow, so use this instead.
            </summary>
        </member>
        <member name="T:Microsoft.ML.Data.IRowToRowMapper">
            <summary>
            This interface maps an input <see cref="T:Microsoft.Data.DataView.DataViewRow"/> to an output <see cref="T:Microsoft.Data.DataView.DataViewRow"/>. Typically, the output contains
            both the input columns and new columns added by the implementing class, although some implementations may
            return a subset of the input columns.
            This interface is similar to <see cref="T:Microsoft.ML.Data.ISchemaBoundRowMapper"/>, except it does not have any input role mappings,
            so to rebind, the same input column names must be used.
            Implementations of this interface are typically created over defined input <see cref="T:Microsoft.Data.DataView.DataViewSchema"/>.
            </summary>
        </member>
        <member name="P:Microsoft.ML.Data.IRowToRowMapper.InputSchema">
            <summary>
            Mappers are defined as accepting inputs with this very specific schema.
            </summary>
        </member>
        <member name="P:Microsoft.ML.Data.IRowToRowMapper.OutputSchema">
            <summary>
            Gets an instance of <see cref="T:Microsoft.Data.DataView.DataViewSchema"/> which describes the columns' names and types in the output generated by this mapper.
            </summary>
        </member>
        <member name="M:Microsoft.ML.Data.IRowToRowMapper.GetDependencies(System.Collections.Generic.IEnumerable{Microsoft.Data.DataView.DataViewSchema.Column})">
            <summary>
            Given a set of columns, return the input columns that are needed to generate those output columns.
            </summary>
        </member>
        <member name="M:Microsoft.ML.Data.IRowToRowMapper.GetRow(Microsoft.Data.DataView.DataViewRow,System.Func{System.Int32,System.Boolean})">
             <summary>
             Get an <see cref="T:Microsoft.Data.DataView.DataViewRow"/> with the indicated active columns, based on the input <paramref name="input"/>.
             The active columns are those for which <paramref name="active"/> returns true. Getting values on inactive
             columns of the returned row will throw. Null predicates are disallowed.
            
             The <see cref="P:Microsoft.Data.DataView.DataViewRow.Schema"/> of <paramref name="input"/> should be the same object as
             <see cref="P:Microsoft.ML.Data.IRowToRowMapper.InputSchema"/>. Implementors of this method should throw if that is not the case. Conversely,
             the returned value must have the same schema as <see cref="P:Microsoft.ML.Data.IRowToRowMapper.OutputSchema"/>.
            
             This method creates a live connection between the input <see cref="T:Microsoft.Data.DataView.DataViewRow"/> and the output <see
             cref="T:Microsoft.Data.DataView.DataViewRow"/>. In particular, when the getters of the output <see cref="T:Microsoft.Data.DataView.DataViewRow"/> are invoked, they invoke the
             getters of the input row and base the output values on the current values of the input <see cref="T:Microsoft.Data.DataView.DataViewRow"/>.
             The output <see cref="T:Microsoft.Data.DataView.DataViewRow"/> values are re-computed when requested through the getters. Also, the returned
             <see cref="T:Microsoft.Data.DataView.DataViewRow"/> will dispose <paramref name="input"/> when it is disposed.
             </summary>
        </member>
        <member name="T:Microsoft.ML.Data.ISchemaBindableMapper">
            <summary>
            A mapper that can be bound to a <see cref="T:Microsoft.ML.Data.RoleMappedSchema"/> (which is an ISchema, with mappings from column kinds
            to columns). Binding an <see cref="T:Microsoft.ML.Data.ISchemaBindableMapper"/> to a <see cref="T:Microsoft.ML.Data.RoleMappedSchema"/> produces an
            <see cref="T:Microsoft.ML.Data.ISchemaBoundMapper"/>, which is an interface that has methods to return the names and indices of the input columns
            needed by the mapper to compute its output. The <see cref="T:Microsoft.ML.Data.ISchemaBoundRowMapper"/> is an extention to this interface, that
            can also produce an output IRow given an input IRow. The IRow produced generally contains only the output columns of the mapper, and not
            the input columns (but there is nothing preventing an <see cref="T:Microsoft.ML.Data.ISchemaBoundRowMapper"/> from mapping input columns directly to outputs).
            This interface is implemented by wrappers of IValueMapper based predictors, which are predictors that take a single
            features column. New predictors can implement <see cref="T:Microsoft.ML.Data.ISchemaBindableMapper"/> directly. Implementing <see cref="T:Microsoft.ML.Data.ISchemaBindableMapper"/>
            includes implementing a corresponding <see cref="T:Microsoft.ML.Data.ISchemaBoundMapper"/> (or <see cref="T:Microsoft.ML.Data.ISchemaBoundRowMapper"/>) and a corresponding ISchema
            for the output schema of the <see cref="T:Microsoft.ML.Data.ISchemaBoundMapper"/>. In case the <see cref="T:Microsoft.ML.Data.ISchemaBoundRowMapper"/> interface is implemented,
            the SimpleRow class can be used in the <see cref="M:Microsoft.ML.Data.IRowToRowMapper.GetRow(Microsoft.Data.DataView.DataViewRow,System.Func{System.Int32,System.Boolean})"/> method.
            </summary>
        </member>
        <member name="T:Microsoft.ML.Data.ISchemaBoundMapper">
            <summary>
            This interface is used to map a schema from input columns to output columns. The <see cref="T:Microsoft.ML.Data.ISchemaBoundMapper"/> should keep track
            of the input columns that are needed for the mapping.
            </summary>
        </member>
        <member name="P:Microsoft.ML.Data.ISchemaBoundMapper.InputRoleMappedSchema">
            <summary>
            The <see cref="T:Microsoft.ML.Data.RoleMappedSchema"/> that was passed to the <see cref="T:Microsoft.ML.Data.ISchemaBoundMapper"/> in the binding process.
            </summary>
        </member>
        <member name="P:Microsoft.ML.Data.ISchemaBoundMapper.OutputSchema">
            <summary>
            Gets schema of this mapper's output.
            </summary>
        </member>
        <member name="P:Microsoft.ML.Data.ISchemaBoundMapper.Bindable">
            <summary>
            A property to get back the <see cref="T:Microsoft.ML.Data.ISchemaBindableMapper"/> that produced this <see cref="T:Microsoft.ML.Data.ISchemaBoundMapper"/>.
            </summary>
        </member>
        <member name="M:Microsoft.ML.Data.ISchemaBoundMapper.GetInputColumnRoles">
            <summary>
            This method returns the binding information: which input columns are used and in what roles.
            </summary>
        </member>
        <member name="T:Microsoft.ML.Data.ISchemaBoundRowMapper">
            <summary>
            This interface extends <see cref="T:Microsoft.ML.Data.ISchemaBoundMapper"/>.
            </summary>
        </member>
        <member name="P:Microsoft.ML.Data.ISchemaBoundRowMapper.InputSchema">
            <summary>
            Input schema accepted.
            </summary>
        </member>
        <member name="M:Microsoft.ML.Data.ISchemaBoundRowMapper.GetDependenciesForNewColumns(System.Collections.Generic.IEnumerable{Microsoft.Data.DataView.DataViewSchema.Column})">
            <summary>
            Given a set of columns, from the newly generated ones, return the input columns that are needed to generate those output columns.
            </summary>
        </member>
        <member name="M:Microsoft.ML.Data.ISchemaBoundRowMapper.GetRow(Microsoft.Data.DataView.DataViewRow,System.Func{System.Int32,System.Boolean})">
             <summary>
             Get an <see cref="T:Microsoft.Data.DataView.DataViewRow"/> with the indicated active columns, based on the input <paramref name="input"/>.
             The active columns are those for which <paramref name="active"/> returns true. Getting values on inactive
             columns of the returned row will throw. Null predicates are disallowed.
            
             The <see cref="P:Microsoft.Data.DataView.DataViewRow.Schema"/> of <paramref name="input"/> should be the same object as
             <see cref="P:Microsoft.ML.Data.ISchemaBoundRowMapper.InputSchema"/>. Implementors of this method should throw if that is not the case. Conversely,
             the returned value must have the same schema as <see cref="P:Microsoft.ML.Data.ISchemaBoundMapper.OutputSchema"/>.
            
             This method creates a live connection between the input <see cref="T:Microsoft.Data.DataView.DataViewRow"/> and the output <see
             cref="T:Microsoft.Data.DataView.DataViewRow"/>. In particular, when the getters of the output <see cref="T:Microsoft.Data.DataView.DataViewRow"/> are invoked, they invoke the
             getters of the input row and base the output values on the current values of the input <see cref="T:Microsoft.Data.DataView.DataViewRow"/>.
             The output <see cref="T:Microsoft.Data.DataView.DataViewRow"/> values are re-computed when requested through the getters. Also, the returned
             <see cref="T:Microsoft.Data.DataView.DataViewRow"/> will dispose <paramref name="input"/> when it is disposed.
             </summary>
        </member>
        <member name="T:Microsoft.ML.Data.ValueMapper`2">
            <summary>
            Delegate type to map/convert a value.
            </summary>
        </member>
        <member name="T:Microsoft.ML.Data.ValueMapper`3">
            <summary>
            Delegate type to map/convert among three values, for example, one input with two
            outputs, or two inputs with one output.
            </summary>
        </member>
        <member name="T:Microsoft.ML.Data.IValueMapper">
            <summary>
            Interface for mapping a single input value (of an indicated ColumnType) to
            an output value (of an indicated ColumnType). This interface is commonly implemented
            by predictors. Note that the input and output ColumnTypes determine the proper
            type arguments for GetMapper, but typically contain additional information like
            vector lengths.
            </summary>
        </member>
        <member name="M:Microsoft.ML.Data.IValueMapper.GetMapper``2">
            <summary>
            Get a delegate used for mapping from input to output values. Note that the delegate
            should only be used on a single thread - it should NOT be assumed to be safe for concurrency.
            </summary>
        </member>
        <member name="T:Microsoft.ML.Data.IValueMapperDist">
            <summary>
            Interface for mapping a single input value (of an indicated ColumnType) to an output value
            plus distribution value (of indicated ColumnTypes). This interface is commonly implemented
            by predictors. Note that the input, output, and distribution ColumnTypes determine the proper
            type arguments for GetMapper, but typically contain additional information like
            vector lengths.
            </summary>
        </member>
        <member name="M:Microsoft.ML.Data.IValueMapperDist.GetMapper``3">
            <summary>
            Get a delegate used for mapping from input to output values. Note that the delegate
            should only be used on a single thread - it should NOT be assumed to be safe for concurrency.
            </summary>
        </member>
        <member name="T:Microsoft.ML.Data.KeyType">
             <summary>
             KeyTypes are for "id"-like data. The information happens to be stored in an unsigned integer
             type, but the information is not inherently numeric, so, typically, arithmetic is not
             meaningful. Examples are SSNs, phone numbers, auto-generated/incremented key values,
             class numbers, etc. For example, in multi-class classification, the label is typically
             a class number which is naturally a KeyType.
            
             KeyTypes have a cardinality (i.e., Count) that is strictly positive.
            
             Note that the underlying representation value does not necessarily match the logical value.
             For example, if a KeyType has range 0-5000, then it has a Count of 5001, but
             the representational values are 1-5001. The representation value zero is reserved
             to mean a missing value (similar to NaN).
             </summary>
        </member>
        <member name="M:Microsoft.ML.Data.KeyType.IsValidDataType(System.Type)">
            <summary>
            Returns true iff the given type is valid for a <see cref="T:Microsoft.ML.Data.KeyType"/>. The valid ones are
            <see cref="T:System.Byte"/>, <see cref="T:System.UInt16"/>, <see cref="T:System.UInt32"/>, and <see cref="T:System.UInt64"/>, that is, the unsigned integer types.
            </summary>
        </member>
        <member name="P:Microsoft.ML.Data.KeyType.Count">
            <summary>
            <see cref="P:Microsoft.ML.Data.KeyType.Count"/> is the cardinality of the <see cref="T:Microsoft.ML.Data.KeyType"/>. Note that such a key type can be converted to a
            bit vector representation by mapping to a vector of length Count, with "id" mapped to a
            vector with 1 in slot (id - 1) and 0 in all other slots. This is the standard "indicator"
            representation. Note that an id of 0 is used to represent the notion "none", which is
            typically mapped, by for example, one-hot encoding, to a vector of all zeros (of length Count).
            </summary>
        </member>
        <member name="T:Microsoft.ML.Data.KeyTypeExtensions">
            <summary>
            Extension methods related to the KeyType class.
            </summary>
        </member>
        <member name="M:Microsoft.ML.Data.KeyTypeExtensions.GetCountAsInt32(Microsoft.ML.Data.KeyType,Microsoft.ML.IExceptionContext)">
            <summary>
            Sometimes it is necessary to cast the Count to an int. This performs overflow check.
            </summary>
        </member>
        <member name="T:Microsoft.ML.Data.LinkedRootCursorBase">
            <summary>
            Base class for a cursor has an input cursor, but still needs to do work on <see cref="M:Microsoft.Data.DataView.DataViewRowCursor.MoveNext"/>.
            </summary>
        </member>
        <member name="P:Microsoft.ML.Data.LinkedRootCursorBase.Input">
            <summary>Gets the input cursor.</summary>
        </member>
        <member name="P:Microsoft.ML.Data.LinkedRootCursorBase.Root">
            <summary>
            Returns the root cursor of the input. It should be used to perform <see cref="M:Microsoft.Data.DataView.DataViewRowCursor.MoveNext"/>
            operations, but with the distinction, as compared to <see cref="T:Microsoft.ML.Data.SynchronizedCursorBase"/>, that this is not
            a simple passthrough, but rather very implementation specific. For example, a common usage of this class is
            on filter cursor implemetnations, where how that input cursor is consumed is very implementation specific.
            That is why this is <see langword="protected"/>, not <see langword="private"/>.
            </summary>
        </member>
        <member name="T:Microsoft.ML.Data.LinkedRowFilterCursorBase">
            <summary>
            Base class for creating a cursor of rows that filters out some input rows.
            </summary>
        </member>
        <member name="M:Microsoft.ML.Data.LinkedRowFilterCursorBase.Accept">
            <summary>
            Return whether the current input row should be returned by this cursor.
            </summary>
        </member>
        <member name="T:Microsoft.ML.Data.LinkedRowRootCursorBase">
            <summary>
            A base class for a <see cref="T:Microsoft.Data.DataView.DataViewRowCursor"/> that has an input cursor, but still needs to do work on
            <see cref="M:Microsoft.Data.DataView.DataViewRowCursor.MoveNext"/>. Note that the default
            <see cref="M:Microsoft.ML.Data.LinkedRowRootCursorBase.GetGetter``1(System.Int32)"/> assumes that each input column is exposed as an
            output column with the same column index.
            </summary>
        </member>
        <member name="P:Microsoft.ML.Data.LinkedRowRootCursorBase.Schema">
            <summary>Gets row's schema.</summary>
        </member>
        <member name="T:Microsoft.ML.Data.ProgressReporting">
            <summary>
            The progress reporting classes used by <see cref="T:Microsoft.ML.Data.HostEnvironmentBase`1"/> descendants.
            </summary>
        </member>
        <member name="T:Microsoft.ML.Data.ProgressReporting.ProgressChannel">
            <summary>
            The progress channel for <see cref="T:Microsoft.ML.Data.ConsoleEnvironment"/>.
            This is coupled with a <see cref="T:Microsoft.ML.Data.ProgressReporting.ProgressTracker"/> that aggregates all events and returns them on demand.
            </summary>
        </member>
        <member name="F:Microsoft.ML.Data.ProgressReporting.ProgressChannel._headerAndAction">
            <summary>
            The pair of (header, fill action) is updated atomically.
            </summary>
        </member>
        <member name="F:Microsoft.ML.Data.ProgressReporting.ProgressChannel._tracker">
            <summary>
            Normally this should be readonly field, but we want to null it in Dispose to prevent memory leaking.
            </summary>
        </member>
        <member name="M:Microsoft.ML.Data.ProgressReporting.ProgressChannel.#ctor(Microsoft.ML.IExceptionContext,Microsoft.ML.Data.ProgressReporting.ProgressTracker,System.String)">
            <summary>
            Initialize a <see cref="T:Microsoft.ML.Data.ProgressReporting.ProgressChannel"/> for the process identified by <paramref name="computationName"/>.
            </summary>
            <param name="ectx">The exception context.</param>
            <param name="tracker">The tracker to couple with.</param>
            <param name="computationName">The computation name.</param>
        </member>
        <member name="M:Microsoft.ML.Data.ProgressReporting.ProgressChannel.GetProgress">
            <summary>
            Pull the current progress by invoking the fill delegate, if any.
            </summary>
        </member>
        <member name="T:Microsoft.ML.Data.ProgressReporting.ProgressChannel.SubChannel">
             <summary>
             This is a 'derived' or 'subordinate' progress channel.
            
             The subordinates' Start/Stop events and checkpoints will not be propagated.
             When the status is requested, all of the subordinate channels are also invoked,
             and the resulting metrics are then returned in the order of their 'subordinate level'.
             If there's more than one channel with the same level, the order is not defined.
             </summary>
        </member>
        <member name="F:Microsoft.ML.Data.ProgressReporting.ProgressChannel.SubChannel._headerAndAction">
            <summary>
            The pair of (header, fill action) is updated atomically.
            </summary>
        </member>
        <member name="M:Microsoft.ML.Data.ProgressReporting.ProgressChannel.SubChannel.GetProgress">
            <summary>
            Pull the current progress by invoking the fill delegate, if any.
            </summary>
        </member>
        <member name="T:Microsoft.ML.Data.ProgressReporting.ProgressTracker">
             <summary>
             This class listens to the progress reporting channels, caches all checkpoints and
             start/stop events and, on demand, requests current progress on all active calculations.
            
             The public methods of this class should only be called from one thread.
             </summary>
        </member>
        <member name="F:Microsoft.ML.Data.ProgressReporting.ProgressTracker._pendingEvents">
            <summary>
            Log of pending events.
            </summary>
        </member>
        <member name="F:Microsoft.ML.Data.ProgressReporting.ProgressTracker._infos">
            <summary>
            For each calculation, its properties.
            This list is protected by <see cref="F:Microsoft.ML.Data.ProgressReporting.ProgressTracker._lock"/>, and it's updated every time a new calculation starts.
            The entries are cleaned up when the start and stop events are reported (that is, after the first
            pull request after the calculation's 'Stop' event).
            </summary>
        </member>
        <member name="F:Microsoft.ML.Data.ProgressReporting.ProgressTracker._index">
            <summary>
            This is a 'process index' that gets incremented whenever a new calculation is started.
            </summary>
        </member>
        <member name="F:Microsoft.ML.Data.ProgressReporting.ProgressTracker._namesUsed">
            <summary>
            The set of used process names.
            </summary>
        </member>
        <member name="T:Microsoft.ML.Data.ProgressReporting.ProgressTracker.CalculationInfo">
             <summary>
             This class is an 'event log' for one calculation.
            
             Every time a calculation is 'started', it gets its own log, so if there are multiple 'start' calls,
             there will be multiple logs.
             </summary>
        </member>
        <member name="F:Microsoft.ML.Data.ProgressReporting.ProgressTracker.CalculationInfo.Index">
            <summary>
            Auto-assigned index to serve as a unique ID.
            </summary>
        </member>
        <member name="F:Microsoft.ML.Data.ProgressReporting.ProgressTracker.CalculationInfo.Name">
            <summary>
            Name is auto-modified from the calculation name provided by the pipe.
            </summary>
        </member>
        <member name="F:Microsoft.ML.Data.ProgressReporting.ProgressTracker.CalculationInfo.PendingCheckpoints">
            <summary>
            A log of pending checkpoint entries.
            </summary>
        </member>
        <member name="F:Microsoft.ML.Data.ProgressReporting.ProgressTracker.CalculationInfo.IsFinished">
            <summary>
            Whether the calculation has finished.
            </summary>
        </member>
        <member name="M:Microsoft.ML.Data.ProgressReporting.ProgressTracker.GetAllProgress">
             <summary>
             Get progress reports from all current calculations.
             For every calculation the following events will be returned:
             * A start event.
             * Each checkpoint.
             * If the calculation is finished, the stop event.
            
             Each of the above events will be returned exactly once.
             If, for one calculation, there's no events in the above categories, the tracker will
             request ('pull') the current progress and return this as an event.
             </summary>
        </member>
        <member name="T:Microsoft.ML.Data.ProgressReporting.ProgressEntry">
            <summary>
            An array-backed implementation of <see cref="T:Microsoft.ML.IProgressEntry"/>.
            </summary>
        </member>
        <member name="F:Microsoft.ML.Data.ProgressReporting.ProgressEntry.Header">
            <summary>
            The header (names of metrics and units).
            The contents of the header should be treated as read-only. The calculation itself doesn't even
            need to access the header, since it will know it anyway.
            </summary>
        </member>
        <member name="F:Microsoft.ML.Data.ProgressReporting.ProgressEntry.IsCheckpoint">
            <summary>
            Whether the progress entry is a 'checkpoint' (that is, it's being pushed by the component).
            </summary>
        </member>
        <member name="F:Microsoft.ML.Data.ProgressReporting.ProgressEntry.Progress">
             <summary>
             The actual progress (amount of completed units), in the units that are contained in the header.
             Parallel to the header's <see cref="F:Microsoft.ML.ProgressHeader.UnitNames"/>. Null value indicates 'not applicable now'.
            
             The computation should not modify these arrays directly, and instead rely on <see cref="M:Microsoft.ML.Data.ProgressReporting.ProgressEntry.SetMetric(System.Int32,System.Double)"/>,
             <see cref="M:Microsoft.ML.Data.ProgressReporting.ProgressEntry.SetProgress(System.Int32,System.Double)"/> and <see cref="M:Microsoft.ML.Data.ProgressReporting.ProgressEntry.SetProgress(System.Int32,System.Double,System.Double)"/>.
             </summary>
        </member>
        <member name="F:Microsoft.ML.Data.ProgressReporting.ProgressEntry.ProgressLim">
            <summary>
            The lim values of each progress unit.
            Parallel to the header's <see cref="F:Microsoft.ML.ProgressHeader.UnitNames"/>. Null value indicates unbounded or unknown.
            </summary>
        </member>
        <member name="F:Microsoft.ML.Data.ProgressReporting.ProgressEntry.Metrics">
            <summary>
            The reported metrics. Parallel to the header's <see cref="F:Microsoft.ML.ProgressHeader.MetricNames"/>.
            Null value indicates unknown.
            </summary>
        </member>
        <member name="M:Microsoft.ML.Data.ProgressReporting.ProgressEntry.SetProgress(System.Int32,System.Double)">
            <summary>
            Set the progress value for the index <paramref name="index"/> to <paramref name="value"/>,
            and the limit value for the progress becomes 'unknown'.
            </summary>
        </member>
        <member name="M:Microsoft.ML.Data.ProgressReporting.ProgressEntry.SetProgress(System.Int32,System.Double,System.Double)">
            <summary>
            Set the progress value for the index <paramref name="index"/> to <paramref name="value"/>,
            and the limit value to <paramref name="lim"/>.
            </summary>
        </member>
        <member name="M:Microsoft.ML.Data.ProgressReporting.ProgressEntry.SetMetric(System.Int32,System.Double)">
            <summary>
            Sets the metric with index <paramref name="index"/> to <paramref name="value"/>.
            </summary>
        </member>
        <member name="M:Microsoft.ML.Data.ProgressReporting.ProgressEntry.#ctor(System.Boolean,Microsoft.ML.ProgressHeader)">
            <summary>
            Creates the progress entry corresponding to a given header.
            </summary>
        </member>
        <member name="T:Microsoft.ML.Data.ProgressReporting.ProgressEvent">
            <summary>
            An event about calculation progress. It could be either start/stop of the calculation, or a progress entry.
            </summary>
        </member>
        <member name="M:Microsoft.ML.Data.ReadOnlyMemoryUtils.EqualsStr(System.String,System.ReadOnlyMemory{System.Char})">
            <summary>
            Compare equality with the given system string value.
            </summary>
        </member>
        <member name="M:Microsoft.ML.Data.ReadOnlyMemoryUtils.SplitOne(System.ReadOnlyMemory{System.Char},System.Char,System.ReadOnlyMemory{System.Char}@,System.ReadOnlyMemory{System.Char}@)">
            <summary>
            Splits <paramref name="memory"/> on the left-most occurrence of separator and produces the left
            and right <see cref="T:System.ReadOnlyMemory`1"/> of <see cref="T:System.Char"/> values. If <paramref name="memory"/> does not contain the separator character,
            this returns false and sets <paramref name="left"/> to this instance and <paramref name="right"/>
            to the default <see cref="T:System.ReadOnlyMemory`1"/> of <see cref="T:System.Char"/> value.
            </summary>
        </member>
        <member name="M:Microsoft.ML.Data.ReadOnlyMemoryUtils.SplitOne(System.ReadOnlyMemory{System.Char},System.Char[],System.ReadOnlyMemory{System.Char}@,System.ReadOnlyMemory{System.Char}@)">
            <summary>
            Splits <paramref name="memory"/> on the left-most occurrence of an element of separators character array and
            produces the left and right <see cref="T:System.ReadOnlyMemory`1"/> of <see cref="T:System.Char"/> values. If <paramref name="memory"/> does not contain any of the
            characters in separators, this return false and initializes <paramref name="left"/> to this instance
            and <paramref name="right"/> to the default <see cref="T:System.ReadOnlyMemory`1"/> of <see cref="T:System.Char"/> value.
            </summary>
        </member>
        <member name="M:Microsoft.ML.Data.ReadOnlyMemoryUtils.TrimSpaces(System.ReadOnlyMemory{System.Char})">
            <summary>
            Returns a <see cref="T:System.ReadOnlyMemory`1"/> of <see cref="T:System.Char"/> with leading and trailing spaces trimmed. Note that this
            will remove only spaces, not any form of whitespace.
            </summary>
        </member>
        <member name="M:Microsoft.ML.Data.ReadOnlyMemoryUtils.TrimWhiteSpace(System.ReadOnlyMemory{System.Char})">
            <summary>
            Returns a <see cref="T:System.ReadOnlyMemory`1"/> of <see cref="T:System.Char"/> with leading and trailing whitespace trimmed.
            </summary>
        </member>
        <member name="M:Microsoft.ML.Data.ReadOnlyMemoryUtils.TrimEndWhiteSpace(System.ReadOnlyMemory{System.Char})">
            <summary>
            Returns a <see cref="T:System.ReadOnlyMemory`1"/> of <see cref="T:System.Char"/> with trailing whitespace trimmed.
            </summary>
        </member>
        <member name="T:Microsoft.ML.Data.RoleMappedSchema">
             <summary>
             Encapsulates an <see cref="P:Microsoft.ML.Data.RoleMappedSchema.Schema"/> plus column role mapping information. The purpose of role mappings is to
             provide information on what the intended usage is for. That is: while a given data view may have a column named
             "Features", by itself that is insufficient: the trainer must be fed a role mapping that says that the role
             mapping for features is filled by that "Features" column. This allows things like columns not named "Features"
             to actually fill that role (as opposed to insisting on a hard coding, or having every trainer have to be
             individually configured). Also, by being a one-to-many mapping, it is a way for learners that can consume
             multiple features columns to consume that information.
            
             This class has convenience fields for several common column roles (for example, <see cref="P:Microsoft.ML.Data.RoleMappedSchema.Feature"/>, <see
             cref="P:Microsoft.ML.Data.RoleMappedSchema.Label"/>), but can hold an arbitrary set of column infos. The convenience fields are non-null if and only
             if there is a unique column with the corresponding role. When there are no such columns or more than one such
             column, the field is <c>null</c>. The <see cref="M:Microsoft.ML.Data.RoleMappedSchema.Has(Microsoft.ML.Data.RoleMappedSchema.ColumnRole)"/>, <see cref="M:Microsoft.ML.Data.RoleMappedSchema.HasUnique(Microsoft.ML.Data.RoleMappedSchema.ColumnRole)"/>, and <see cref="M:Microsoft.ML.Data.RoleMappedSchema.HasMultiple(Microsoft.ML.Data.RoleMappedSchema.ColumnRole)"/>
             methods provide some cardinality information. Note that all columns assigned roles are guaranteed to be non-hidden
             in this schema.
             </summary>
             <remarks>
             Note that instances of this class are, like instances of <see cref="P:Microsoft.ML.Data.RoleMappedSchema.Schema"/>, immutable.
            
             It is often the case that one wishes to bundle the actual data with the role mappings, not just the schema. For
             that case, please use the <see cref="T:Microsoft.ML.Data.RoleMappedData"/> class.
            
             Note that there is no need for components consuming a <see cref="T:Microsoft.ML.Data.RoleMappedData"/> or <see cref="T:Microsoft.ML.Data.RoleMappedSchema"/>
             to make use of every defined mapping. Consuming components are also expected to ignore any <see cref="T:Microsoft.ML.Data.RoleMappedSchema.ColumnRole"/>
             they do not handle. They may very well however complain if a mapping they wanted to see is not present, or the column(s)
             mapped from the role are not of the form they require.
             </remarks>
             <seealso cref="T:Microsoft.ML.Data.RoleMappedSchema.ColumnRole"/>
             <seealso cref="T:Microsoft.ML.Data.RoleMappedData"/>
        </member>
        <member name="T:Microsoft.ML.Data.RoleMappedSchema.ColumnRole">
            <summary>
            Instances of this are the keys of a <see cref="T:Microsoft.ML.Data.RoleMappedSchema"/>. This class also holds some important
            commonly used pre-defined instances available (for example, <see cref="P:Microsoft.ML.Data.RoleMappedSchema.ColumnRole.Label"/>, <see cref="P:Microsoft.ML.Data.RoleMappedSchema.ColumnRole.Feature"/>) that should
            be used when possible for consistency reasons. However, practitioners should not be afraid to declare custom
            roles if approppriate for their task.
            </summary>
        </member>
        <member name="P:Microsoft.ML.Data.RoleMappedSchema.ColumnRole.Feature">
            <summary>
            Role for features. Commonly used as the independent variables given to trainers, and scorers.
            </summary>
        </member>
        <member name="P:Microsoft.ML.Data.RoleMappedSchema.ColumnRole.Label">
            <summary>
            Role for labels. Commonly used as the dependent variables given to trainers, and evaluators.
            </summary>
        </member>
        <member name="P:Microsoft.ML.Data.RoleMappedSchema.ColumnRole.Group">
            <summary>
            Role for group ID. Commonly used in ranking applications, for defining query boundaries, or
            sequence classification, for defining the boundaries of an utterance.
            </summary>
        </member>
        <member name="P:Microsoft.ML.Data.RoleMappedSchema.ColumnRole.Weight">
            <summary>
            Role for sample weights. Commonly used to point to a number to make trainers give more weight
            to a particular example.
            </summary>
        </member>
        <member name="P:Microsoft.ML.Data.RoleMappedSchema.ColumnRole.Name">
            <summary>
            Role for sample names. Useful for informational and tracking purposes when scoring, but typically
            without affecting results.
            </summary>
        </member>
        <member name="P:Microsoft.ML.Data.RoleMappedSchema.ColumnRole.FeatureContributions">
            <summary>
            Role for feature contributions. Useful for specific diagnostic functionality.
            </summary>
        </member>
        <member name="F:Microsoft.ML.Data.RoleMappedSchema.ColumnRole.Value">
            <summary>
            The string value for the role. Guaranteed to be non-empty.
            </summary>
        </member>
        <member name="M:Microsoft.ML.Data.RoleMappedSchema.ColumnRole.#ctor(System.String)">
            <summary>
            Constructor for the column role.
            </summary>
            <param name="value">The value for the role. Must be non-empty.</param>
        </member>
        <member name="M:Microsoft.ML.Data.RoleMappedSchema.ColumnRole.Bind(System.String)">
            <summary>
            Convenience method for creating a mapping pair from a role to a column name
            for giving to constructors of <see cref="T:Microsoft.ML.Data.RoleMappedSchema"/> and <see cref="T:Microsoft.ML.Data.RoleMappedData"/>.
            </summary>
            <param name="name">The column name to map to. Can be <c>null</c>, in which case when used
            to construct a role mapping structure this pair will be ignored</param>
            <returns>A key-value pair with this instance as the key and <paramref name="name"/> as the value</returns>
        </member>
        <member name="P:Microsoft.ML.Data.RoleMappedSchema.Schema">
            <summary>
            The source <see cref="P:Microsoft.ML.Data.RoleMappedSchema.Schema"/>.
            </summary>
        </member>
        <member name="P:Microsoft.ML.Data.RoleMappedSchema.Feature">
            <summary>
            The <see cref="P:Microsoft.ML.Data.RoleMappedSchema.ColumnRole.Feature"/> column, when there is exactly one (null otherwise).
            </summary>
        </member>
        <member name="P:Microsoft.ML.Data.RoleMappedSchema.Label">
            <summary>
            The <see cref="P:Microsoft.ML.Data.RoleMappedSchema.ColumnRole.Label"/> column, when there is exactly one (null otherwise).
            </summary>
        </member>
        <member name="P:Microsoft.ML.Data.RoleMappedSchema.Group">
            <summary>
            The <see cref="P:Microsoft.ML.Data.RoleMappedSchema.ColumnRole.Group"/> column, when there is exactly one (null otherwise).
            </summary>
        </member>
        <member name="P:Microsoft.ML.Data.RoleMappedSchema.Weight">
            <summary>
            The <see cref="P:Microsoft.ML.Data.RoleMappedSchema.ColumnRole.Weight"/> column, when there is exactly one (null otherwise).
            </summary>
        </member>
        <member name="P:Microsoft.ML.Data.RoleMappedSchema.Name">
            <summary>
            The <see cref="P:Microsoft.ML.Data.RoleMappedSchema.ColumnRole.Name"/> column, when there is exactly one (null otherwise).
            </summary>
        </member>
        <member name="M:Microsoft.ML.Data.RoleMappedSchema.Has(Microsoft.ML.Data.RoleMappedSchema.ColumnRole)">
            <summary>
            Returns whether there are any columns with the given column role.
            </summary>
        </member>
        <member name="M:Microsoft.ML.Data.RoleMappedSchema.HasUnique(Microsoft.ML.Data.RoleMappedSchema.ColumnRole)">
            <summary>
            Returns whether there is exactly one column of the given role.
            </summary>
        </member>
        <member name="M:Microsoft.ML.Data.RoleMappedSchema.HasMultiple(Microsoft.ML.Data.RoleMappedSchema.ColumnRole)">
            <summary>
            Returns whether there are two or more columns of the given role.
            </summary>
        </member>
        <member name="M:Microsoft.ML.Data.RoleMappedSchema.GetColumns(Microsoft.ML.Data.RoleMappedSchema.ColumnRole)">
            <summary>
            If there are columns of the given role, this returns the infos as a readonly list. Otherwise,
            it returns null.
            </summary>
        </member>
        <member name="M:Microsoft.ML.Data.RoleMappedSchema.GetColumnRoles">
            <summary>
            An enumerable over all role-column associations within this object.
            </summary>
        </member>
        <member name="M:Microsoft.ML.Data.RoleMappedSchema.GetColumnRoleNames">
            <summary>
            An enumerable over all role-column associations within this object.
            </summary>
        </member>
        <member name="M:Microsoft.ML.Data.RoleMappedSchema.GetColumnRoleNames(Microsoft.ML.Data.RoleMappedSchema.ColumnRole)">
            <summary>
            An enumerable over all role-column associations for the given role. This is a helper function
            for implementing the <see cref="M:Microsoft.ML.Data.ISchemaBoundMapper.GetInputColumnRoles"/> method.
            </summary>
        </member>
        <member name="M:Microsoft.ML.Data.RoleMappedSchema.GetUniqueColumn(Microsoft.ML.Data.RoleMappedSchema.ColumnRole)">
            <summary>
            Returns the <see cref="T:Microsoft.Data.DataView.DataViewSchema.Column"/> corresponding to <paramref name="role"/> if there is
            exactly one such mapping, and otherwise throws an exception.
            </summary>
            <param name="role">The role to look up</param>
            <returns>The column corresponding to that role, assuming there was only one column
            mapped to that</returns>
        </member>
        <member name="M:Microsoft.ML.Data.RoleMappedSchema.#ctor(Microsoft.Data.DataView.DataViewSchema,System.Boolean,System.Collections.Generic.KeyValuePair{Microsoft.ML.Data.RoleMappedSchema.ColumnRole,System.String}[])">
            <summary>
            Constructor given a schema, and mapping pairs of roles to columns in the schema.
            This skips null or empty column-names. It will also skip column-names that are not
            found in the schema if <paramref name="opt"/> is true.
            </summary>
            <param name="schema">The schema over which roles are defined</param>
            <param name="opt">Whether to consider the column names specified "optional" or not. If <c>false</c> then any non-empty
            values for the column names that does not appear in <paramref name="schema"/> will result in an exception being thrown,
            but if <c>true</c> such values will be ignored</param>
            <param name="roles">The column role to column name mappings</param>
        </member>
        <member name="M:Microsoft.ML.Data.RoleMappedSchema.#ctor(Microsoft.Data.DataView.DataViewSchema,System.Collections.Generic.IEnumerable{System.Collections.Generic.KeyValuePair{Microsoft.ML.Data.RoleMappedSchema.ColumnRole,System.String}},System.Boolean)">
            <summary>
            Constructor given a schema, and mapping pairs of roles to columns in the schema.
            This skips null or empty column names. It will also skip column-names that are not
            found in the schema if <paramref name="opt"/> is true.
            </summary>
            <param name="schema">The schema over which roles are defined</param>
            <param name="roles">The column role to column name mappings</param>
            <param name="opt">Whether to consider the column names specified "optional" or not. If <c>false</c> then any non-empty
            values for the column names that does not appear in <paramref name="schema"/> will result in an exception being thrown,
            but if <c>true</c> such values will be ignored</param>
        </member>
        <member name="M:Microsoft.ML.Data.RoleMappedSchema.#ctor(Microsoft.Data.DataView.DataViewSchema,System.String,System.String,System.String,System.String,System.String,System.Collections.Generic.IEnumerable{System.Collections.Generic.KeyValuePair{Microsoft.ML.Data.RoleMappedSchema.ColumnRole,System.String}},System.Boolean)">
            <summary>
            Convenience constructor for role-mappings over the commonly used roles. Note that if any column name specified
            is <c>null</c> or whitespace, it is ignored.
            </summary>
            <param name="schema">The schema over which roles are defined</param>
            <param name="label">The column name that will be mapped to the <see cref="P:Microsoft.ML.Data.RoleMappedSchema.ColumnRole.Label"/> role</param>
            <param name="feature">The column name that will be mapped to the <see cref="P:Microsoft.ML.Data.RoleMappedSchema.ColumnRole.Feature"/> role</param>
            <param name="group">The column name that will be mapped to the <see cref="P:Microsoft.ML.Data.RoleMappedSchema.ColumnRole.Group"/> role</param>
            <param name="weight">The column name that will be mapped to the <see cref="P:Microsoft.ML.Data.RoleMappedSchema.ColumnRole.Weight"/> role</param>
            <param name="name">The column name that will be mapped to the <see cref="P:Microsoft.ML.Data.RoleMappedSchema.ColumnRole.Name"/> role</param>
            <param name="custom">Any additional desired custom column role mappings</param>
            <param name="opt">Whether to consider the column names specified "optional" or not. If <c>false</c> then any non-empty
            values for the column names that does not appear in <paramref name="schema"/> will result in an exception being thrown,
            but if <c>true</c> such values will be ignored</param>
        </member>
        <member name="T:Microsoft.ML.Data.RoleMappedData">
            <summary>
            Encapsulates an <see cref="T:Microsoft.Data.DataView.IDataView"/> plus a corresponding <see cref="T:Microsoft.ML.Data.RoleMappedSchema"/>.
            Note that the schema of <see cref="P:Microsoft.ML.Data.RoleMappedSchema.Schema"/> of <see cref="P:Microsoft.ML.Data.RoleMappedData.Schema"/> is
            guaranteed to equal the the <see cref="P:Microsoft.Data.DataView.IDataView.Schema"/> of <see cref="P:Microsoft.ML.Data.RoleMappedData.Data"/>.
            </summary>
        </member>
        <member name="P:Microsoft.ML.Data.RoleMappedData.Data">
            <summary>
            The data.
            </summary>
        </member>
        <member name="P:Microsoft.ML.Data.RoleMappedData.Schema">
            <summary>
            The role mapped schema. Note that <see cref="P:Microsoft.ML.Data.RoleMappedData.Schema"/>'s <see cref="P:Microsoft.ML.Data.RoleMappedSchema.Schema"/> is
            guaranteed to be the same as <see cref="P:Microsoft.ML.Data.RoleMappedData.Data"/>'s <see cref="P:Microsoft.Data.DataView.IDataView.Schema"/>.
            </summary>
        </member>
        <member name="M:Microsoft.ML.Data.RoleMappedData.#ctor(Microsoft.Data.DataView.IDataView,System.Boolean,System.Collections.Generic.KeyValuePair{Microsoft.ML.Data.RoleMappedSchema.ColumnRole,System.String}[])">
            <summary>
            Constructor given a data view, and mapping pairs of roles to columns in the data view's schema.
            This skips null or empty column-names. It will also skip column-names that are not
            found in the schema if <paramref name="opt"/> is true.
            </summary>
            <param name="data">The data over which roles are defined</param>
            <param name="opt">Whether to consider the column names specified "optional" or not. If <c>false</c> then any non-empty
            values for the column names that does not appear in <paramref name="data"/>'s schema will result in an exception being thrown,
            but if <c>true</c> such values will be ignored</param>
            <param name="roles">The column role to column name mappings</param>
        </member>
        <member name="M:Microsoft.ML.Data.RoleMappedData.#ctor(Microsoft.Data.DataView.IDataView,System.Collections.Generic.IEnumerable{System.Collections.Generic.KeyValuePair{Microsoft.ML.Data.RoleMappedSchema.ColumnRole,System.String}},System.Boolean)">
            <summary>
            Constructor given a data view, and mapping pairs of roles to columns in the data view's schema.
            This skips null or empty column-names. It will also skip column-names that are not
            found in the schema if <paramref name="opt"/> is true.
            </summary>
            <param name="data">The schema over which roles are defined</param>
            <param name="roles">The column role to column name mappings</param>
            <param name="opt">Whether to consider the column names specified "optional" or not. If <c>false</c> then any non-empty
            values for the column names that does not appear in <paramref name="data"/>'s schema will result in an exception being thrown,
            but if <c>true</c> such values will be ignored</param>
        </member>
        <member name="M:Microsoft.ML.Data.RoleMappedData.#ctor(Microsoft.Data.DataView.IDataView,System.String,System.String,System.String,System.String,System.String,System.Collections.Generic.IEnumerable{System.Collections.Generic.KeyValuePair{Microsoft.ML.Data.RoleMappedSchema.ColumnRole,System.String}},System.Boolean)">
            <summary>
            Convenience constructor for role-mappings over the commonly used roles. Note that if any column name specified
            is <c>null</c> or whitespace, it is ignored.
            </summary>
            <param name="data">The data over which roles are defined</param>
            <param name="label">The column name that will be mapped to the <see cref="P:Microsoft.ML.Data.RoleMappedSchema.ColumnRole.Label"/> role</param>
            <param name="feature">The column name that will be mapped to the <see cref="P:Microsoft.ML.Data.RoleMappedSchema.ColumnRole.Feature"/> role</param>
            <param name="group">The column name that will be mapped to the <see cref="P:Microsoft.ML.Data.RoleMappedSchema.ColumnRole.Group"/> role</param>
            <param name="weight">The column name that will be mapped to the <see cref="P:Microsoft.ML.Data.RoleMappedSchema.ColumnRole.Weight"/> role</param>
            <param name="name">The column name that will be mapped to the <see cref="P:Microsoft.ML.Data.RoleMappedSchema.ColumnRole.Name"/> role</param>
            <param name="custom">Any additional desired custom column role mappings</param>
            <param name="opt">Whether to consider the column names specified "optional" or not. If <c>false</c> then any non-empty
            values for the column names that does not appear in <paramref name="data"/>'s schema will result in an exception being thrown,
            but if <c>true</c> such values will be ignored</param>
        </member>
        <member name="T:Microsoft.ML.Data.RootCursorBase">
            <summary>
            Base class for creating a cursor with default tracking of <see cref="P:Microsoft.ML.Data.RootCursorBase.Position"/>. All calls to <see cref="M:Microsoft.ML.Data.RootCursorBase.MoveNext"/>
            will be seen by subclasses of this cursor. For a cursor that has an input cursor and does not need notification on
            <see cref="M:Microsoft.ML.Data.RootCursorBase.MoveNext"/>, use <see cref="T:Microsoft.ML.Data.SynchronizedCursorBase"/> instead.
            </summary>
        </member>
        <member name="P:Microsoft.ML.Data.RootCursorBase.Position">
            <summary>
            Zero-based position of the cursor.
            </summary>
        </member>
        <member name="P:Microsoft.ML.Data.RootCursorBase.IsGood">
            <summary>
            Convenience property for checking whether the current state of the cursor is one where data can be fetched.
            </summary>
        </member>
        <member name="M:Microsoft.ML.Data.RootCursorBase.#ctor(Microsoft.ML.IChannelProvider)">
            <summary>
            Creates an instance of the <see cref="T:Microsoft.ML.Data.RootCursorBase"/> class
            </summary>
            <param name="provider">Channel provider</param>
        </member>
        <member name="M:Microsoft.ML.Data.RootCursorBase.MoveNextCore">
            <summary>
            Core implementation of <see cref="M:Microsoft.ML.Data.RootCursorBase.MoveNext"/>, called if no prior call to this method
            has returned <see langword="false"/>.
            </summary>
        </member>
        <member name="M:Microsoft.ML.Data.SchemaExtensions.TryGetColumnIndex(Microsoft.Data.DataView.DataViewSchema,System.String,System.Int32@)">
            <summary>
            Legacy method to get the column index.
            DO NOT USE: use <see cref="M:Microsoft.Data.DataView.DataViewSchema.GetColumnOrNull(System.String)"/> instead.
            </summary>
        </member>
        <member name="T:Microsoft.ML.Data.SynchronizedCursorBase">
            <summary>
            Base class for creating a cursor on top of another cursor that does not add or remove rows.
            It forces one-to-one correspondence between items in the input cursor and this cursor.
            It delegates all ICursor functionality except Dispose() to the root cursor.
            Dispose is virtual with the default implementation delegating to the input cursor.
            </summary>
        </member>
        <member name="F:Microsoft.ML.Data.SynchronizedCursorBase.Root">
            <summary>
            The synchronized cursor base, as it merely passes through requests for all "positional" calls (including
            <see cref="M:Microsoft.ML.Data.SynchronizedCursorBase.MoveNext"/>, <see cref="P:Microsoft.ML.Data.SynchronizedCursorBase.Position"/>, <see cref="P:Microsoft.ML.Data.SynchronizedCursorBase.Batch"/>, and so forth), offers an opportunity
            for optimization for "wrapping" cursors (which are themselves often <see cref="T:Microsoft.ML.Data.SynchronizedCursorBase"/>
            implementors) to get this root cursor. But, this can only be done by exposing this root cursor, as we do here.
            Internal code should be quite careful in using this as the potential for misuse is quite high.
            </summary>
        </member>
        <member name="P:Microsoft.ML.Data.SynchronizedCursorBase.IsGood">
            <summary>
            Convenience property for checking whether the cursor is in a good state where values
            can be retrieved, that is, whenever <see cref="P:Microsoft.ML.Data.SynchronizedCursorBase.Position"/> is non-negative.
            </summary>
        </member>
        <member name="T:Microsoft.ML.Data.VBuffer`1">
            <summary>
            A buffer that supports both dense and sparse representations. This is the
            representation type for all VectorType instances. When an instance of this
            is passed to a row cursor getter, the callee is free to take ownership of
            and re-use the arrays (Values and Indices).
            </summary>
        </member>
        <member name="F:Microsoft.ML.Data.VBuffer`1._count">
            <summary>
            The number of items explicitly represented. This is == Length when the representation
            is dense and &lt; Length when sparse.
            </summary>
        </member>
        <member name="F:Microsoft.ML.Data.VBuffer`1.Length">
            <summary>
            The logical length of the buffer.
            </summary>
        </member>
        <member name="M:Microsoft.ML.Data.VBuffer`1.GetValues">
            <summary>
            The explicitly represented values.
            </summary>
        </member>
        <member name="M:Microsoft.ML.Data.VBuffer`1.GetIndices">
            <summary>
            The indices. For a dense representation, this array is not used. For a sparse representation
            it is parallel to values and specifies the logical indices for the corresponding values.
            </summary>
            <remarks>
            For example, if GetIndices() returns [3, 5] and GetValues() produces [98, 76], this VBuffer
            stands for a vector with:
             - non-zeros values 98 and 76 respectively at the 4th and 6th coordinates
             - zeros at all other coordinates
            </remarks>
        </member>
        <member name="P:Microsoft.ML.Data.VBuffer`1.IsDense">
            <summary>
            Gets a value indicating whether every logical element is explicitly
            represented in the buffer.
            </summary>
        </member>
        <member name="M:Microsoft.ML.Data.VBuffer`1.#ctor(System.Int32,`0[],System.Int32[])">
            <summary>
            Construct a dense representation with unused Indices array.
            </summary>
        </member>
        <member name="M:Microsoft.ML.Data.VBuffer`1.#ctor(System.Int32,System.Int32,`0[],System.Int32[])">
            <summary>
            Construct a possibly sparse representation.
            </summary>
        </member>
        <member name="M:Microsoft.ML.Data.VBuffer`1.CopyToDense(Microsoft.ML.Data.VBuffer{`0}@)">
            <summary>
            Copy from this buffer to the given destination, forcing a dense representation.
            </summary>
        </member>
        <member name="M:Microsoft.ML.Data.VBuffer`1.CopyTo(Microsoft.ML.Data.VBuffer{`0}@)">
            <summary>
            Copy from this buffer to the given destination.
            </summary>
        </member>
        <member name="M:Microsoft.ML.Data.VBuffer`1.CopyTo(Microsoft.ML.Data.VBuffer{`0}@,System.Int32,System.Int32)">
            <summary>
            Copy a range of values from this buffer to the given destination.
            </summary>
        </member>
        <member name="M:Microsoft.ML.Data.VBuffer`1.CopyTo(System.Span{`0})">
            <summary>
            Copy from this buffer to the given destination array. This "densifies".
            </summary>
        </member>
        <member name="M:Microsoft.ML.Data.VBuffer`1.Copy(`0[],System.Int32,Microsoft.ML.Data.VBuffer{`0}@,System.Int32)">
            <summary>
            Copy from a section of a source array to the given destination.
            </summary>
        </member>
        <member name="T:Microsoft.ML.Data.VBufferEditor">
            <summary>
            Various methods for creating <see cref="T:Microsoft.ML.Data.VBufferEditor`1"/> instances.
            </summary>
        </member>
        <member name="M:Microsoft.ML.Data.VBufferEditor.CreateFromBuffer``1(Microsoft.ML.Data.VBuffer{``0}@)">
            <summary>
            Creates a <see cref="T:Microsoft.ML.Data.VBufferEditor`1"/> with the same shape
            (length and density) as the <paramref name="destination"/>.
            </summary>
        </member>
        <member name="M:Microsoft.ML.Data.VBufferEditor.Create``1(Microsoft.ML.Data.VBuffer{``0}@,System.Int32,System.Nullable{System.Int32},System.Boolean,System.Boolean)">
            <summary>
            Creates a <see cref="T:Microsoft.ML.Data.VBufferEditor`1"/> using
            <paramref name="destination"/>'s values and indices buffers.
            </summary>
            <param name="destination">
            The destination buffer.
            </param>
            <param name="newLogicalLength">
            The logical length of the new buffer being edited.
            </param>
            <param name="valuesCount">
            The optional number of physical values to be represented in the buffer.
            The buffer will be dense if <paramref name="valuesCount"/> is omitted.
            </param>
            <param name="keepOldOnResize">
            True means that the old buffer values and indices are preserved, if possible (Array.Resize is called).
            False means that a new array will be allocated, if necessary.
            </param>
            <param name="requireIndicesOnDense">
            True means to ensure the Indices buffer is available, even if the buffer will be dense.
            </param>
        </member>
        <member name="T:Microsoft.ML.Data.VBufferEditor`1">
            <summary>
            An object capable of editing a <see cref="T:Microsoft.ML.Data.VBuffer`1"/> by filling out
            <see cref="F:Microsoft.ML.Data.VBufferEditor`1.Values"/> (and <see cref="F:Microsoft.ML.Data.VBufferEditor`1.Indices"/> if the buffer is not dense).
            </summary>
        </member>
        <member name="F:Microsoft.ML.Data.VBufferEditor`1.Values">
            <summary>
            The mutable span of values.
            </summary>
        </member>
        <member name="F:Microsoft.ML.Data.VBufferEditor`1.Indices">
            <summary>
            The mutable span of indices.
            </summary>
        </member>
        <member name="P:Microsoft.ML.Data.VBufferEditor`1.CreatedNewValues">
            <summary>
            Gets a value indicating whether a new Values array was allocated.
            </summary>
        </member>
        <member name="P:Microsoft.ML.Data.VBufferEditor`1.CreatedNewIndices">
            <summary>
            Gets a value indicating whether a new Indices array was allocated.
            </summary>
        </member>
        <member name="M:Microsoft.ML.Data.VBufferEditor`1.Commit">
            <summary>
            Commits the edits and creates a new <see cref="T:Microsoft.ML.Data.VBuffer`1"/> using
            the current Values and Indices.
            </summary>
            <returns>
            The newly created <see cref="T:Microsoft.ML.Data.VBuffer`1"/>.
            </returns>
        </member>
        <member name="M:Microsoft.ML.Data.VBufferEditor`1.CommitTruncated(System.Int32)">
            <summary>
            Commits the edits and creates a new <see cref="T:Microsoft.ML.Data.VBuffer`1"/> using
            the current Values and Indices, while allowing to truncate the length
            of Values and Indices.
            </summary>
            <param name="physicalValuesCount">
            The new number of physical values to be represented in the created buffer.
            </param>
            <returns>
            The newly created <see cref="T:Microsoft.ML.Data.VBuffer`1"/>.
            </returns>
            <remarks>
            CommitTruncated allows to modify the length of the explicitly
            defined values.
            This is useful in sparse situations where the <see cref="T:Microsoft.ML.Data.VBufferEditor`1"/>
            was created with a larger physical value count than was needed
            because the final value count was not known at creation time.
            </remarks>
        </member>
        <member name="T:Microsoft.ML.Data.VectorType">
            <summary>
            The standard vector type.
            </summary>
        </member>
        <member name="P:Microsoft.ML.Data.VectorType.Dimensions">
            <summary>
            The dimensions. This will always have at least one item. All values will be non-negative.
            As with <see cref="P:Microsoft.ML.Data.VectorType.Size"/>, a zero value indicates that the vector type is considered to have
            unknown length along that dimension.
            </summary>
        </member>
        <member name="M:Microsoft.ML.Data.VectorType.#ctor(Microsoft.Data.DataView.PrimitiveDataViewType,System.Int32)">
            <summary>
            Constructs a new single-dimensional vector type.
            </summary>
            <param name="itemType">The type of the items contained in the vector.</param>
            <param name="size">The size of the single dimension.</param>
        </member>
        <member name="M:Microsoft.ML.Data.VectorType.#ctor(Microsoft.Data.DataView.PrimitiveDataViewType,System.Int32[])">
            <summary>
            Constructs a potentially multi-dimensional vector type.
            </summary>
            <param name="itemType">The type of the items contained in the vector.</param>
            <param name="dimensions">The dimensions. Note that, like <see cref="P:Microsoft.ML.Data.VectorType.Dimensions"/>, must be non-empty, with all
            non-negative values. Also, because <see cref="P:Microsoft.ML.Data.VectorType.Size"/> is the product of <see cref="P:Microsoft.ML.Data.VectorType.Dimensions"/>, the result of
            multiplying all these values together must not overflow <see cref="T:System.Int32"/>.</param>
        </member>
        <member name="M:Microsoft.ML.Data.VectorType.#ctor(Microsoft.Data.DataView.PrimitiveDataViewType,Microsoft.ML.Data.VectorType)">
            <summary>
            Creates a <see cref="T:Microsoft.ML.Data.VectorType"/> whose dimensionality information is the given <paramref name="template"/>'s information.
            </summary>
        </member>
        <member name="M:Microsoft.ML.Data.VectorType.#ctor(Microsoft.Data.DataView.PrimitiveDataViewType,Microsoft.ML.Data.VectorType,System.Int32[])">
            <summary>
            Creates a <see cref="T:Microsoft.ML.Data.VectorType"/> whose dimensionality information is the given <paramref name="template"/>'s information,
            concatenated with the specified <paramref name="dims"/>.
            </summary>
        </member>
        <member name="P:Microsoft.ML.Data.VectorType.IsKnownSize">
            <summary>
            Whether this is a vector type with known size.
            Equivalent to <c><see cref="P:Microsoft.ML.Data.VectorType.Size"/> &gt; 0</c>.
            </summary>
        </member>
        <member name="P:Microsoft.ML.Data.VectorType.ItemType">
            <summary>
            The type of the items stored as values in vectors of this type.
            </summary>
        </member>
        <member name="P:Microsoft.ML.Data.VectorType.Size">
            <summary>
            The size of the vector. A value of zero means it is a vector whose size is unknown.
            A vector whose size is known should correspond to values that always have the same <see cref="F:Microsoft.ML.Data.VBuffer`1.Length"/>,
            whereas one whose size is unknown may have values whose <see cref="F:Microsoft.ML.Data.VBuffer`1.Length"/> varies from record to record.
            Note that this is always the product of the elements in <see cref="P:Microsoft.ML.Data.VectorType.Dimensions"/>.
            </summary>
        </member>
        <member name="T:Microsoft.ML.Data.WrappingRow">
            <summary>
            Convenient base class for <see cref="T:Microsoft.Data.DataView.DataViewRow"/> implementors that wrap a single <see cref="T:Microsoft.Data.DataView.DataViewRow"/>
            as their input. The <see cref="P:Microsoft.Data.DataView.DataViewRow.Position"/>, <see cref="P:Microsoft.Data.DataView.DataViewRow.Batch"/>, and <see cref="M:Microsoft.Data.DataView.DataViewRow.GetIdGetter"/>
            are taken from this <see cref="P:Microsoft.ML.Data.WrappingRow.Input"/>.
            </summary>
        </member>
        <member name="P:Microsoft.ML.Data.WrappingRow.Input">
            <summary>
            The wrapped input row.
            </summary>
        </member>
        <member name="M:Microsoft.ML.Data.WrappingRow.Dispose(System.Boolean)">
            <summary>
            This override of the dispose method by default only calls <see cref="P:Microsoft.ML.Data.WrappingRow.Input"/>'s
            <see cref="M:System.IDisposable.Dispose"/> method, but subclasses can enable additional functionality
            via the <see cref="M:Microsoft.ML.Data.WrappingRow.DisposeCore(System.Boolean)"/> functionality.
            </summary>
            <param name="disposing"></param>
        </member>
        <member name="M:Microsoft.ML.Data.WrappingRow.DisposeCore(System.Boolean)">
            <summary>
            Called from <see cref="M:Microsoft.ML.Data.WrappingRow.Dispose(System.Boolean)"/> with <see langword="true"/> in the case where
            that method has never been called before, and right after <see cref="P:Microsoft.ML.Data.WrappingRow.Input"/> has been
            disposed. The default implementation does nothing.
            </summary>
            <param name="disposing">Whether this was called through the dispose path, as opposed
            to the finalizer path.</param>
        </member>
        <member name="T:Microsoft.ML.Data.ConsoleEnvironment">
            <summary>
            The console environment. As its name suggests, should be limited to those applications that deliberately want
            console functionality.
            </summary>
        </member>
        <member name="M:Microsoft.ML.Data.ConsoleEnvironment.ConsoleWriter.GetAndPrintAllProgress(Microsoft.ML.Data.ProgressReporting.ProgressTracker)">
            <summary>
            Query all progress and:
            * If there's any checkpoint/start/stop event, print all of them.
            * If there's none, print a dot.
            * If there's <see cref="F:Microsoft.ML.Data.ConsoleEnvironment.ConsoleWriter._maxDots"/> dots, print the current status for all running calculations.
            </summary>
        </member>
        <member name="M:Microsoft.ML.Data.ConsoleEnvironment.ConsoleWriter.EnsureNewLine(System.Boolean)">
            <summary>
            If we printed any dots so far, finish the line. This call is expected to be protected by _lock.
            </summary>
        </member>
        <member name="M:Microsoft.ML.Data.ConsoleEnvironment.ConsoleWriter.PrintDot">
            <summary>
            Print a progress dot. Returns whether it is 'time' to print more info. This call is expected
            to be protected by _lock.
            </summary>
        </member>
        <member name="M:Microsoft.ML.Data.ConsoleEnvironment.#ctor(System.Nullable{System.Int32},System.Boolean,Microsoft.ML.MessageSensitivity,System.Int32,System.IO.TextWriter,System.IO.TextWriter)">
            <summary>
            Create an ML.NET <see cref="T:Microsoft.ML.IHostEnvironment"/> for local execution, with console feedback.
            </summary>
            <param name="seed">Random seed. Set to <c>null</c> for a non-deterministic environment.</param>
            <param name="verbose">Set to <c>true</c> for fully verbose logging.</param>
            <param name="sensitivity">Allowed message sensitivity.</param>
            <param name="conc">Concurrency level. Set to 1 to run single-threaded. Set to 0 to pick automatically.</param>
            <param name="outWriter">Text writer to print normal messages to.</param>
            <param name="errWriter">Text writer to print error messages to.</param>
        </member>
        <member name="M:Microsoft.ML.Data.ConsoleEnvironment.#ctor(System.Random,System.Boolean,Microsoft.ML.MessageSensitivity,System.Int32,System.IO.TextWriter,System.IO.TextWriter)">
            <summary>
            Create an ML.NET environment for local execution, with console feedback.
            </summary>
            <param name="rand">An custom source of randomness to use in the environment.</param>
            <param name="verbose">Set to <c>true</c> for fully verbose logging.</param>
            <param name="sensitivity">Allowed message sensitivity.</param>
            <param name="conc">Concurrency level. Set to 1 to run single-threaded. Set to 0 to pick automatically.</param>
            <param name="outWriter">Text writer to print normal messages to.</param>
            <param name="errWriter">Text writer to print error messages to.</param>
        </member>
        <member name="M:Microsoft.ML.Data.ConsoleEnvironment.PrintProgress">
            <summary>
            Pull running calculations for their progress and output all messages to the console.
            If no messages are available, print a dot.
            If a specified number of dots are printed, print an ad-hoc status of all running calculations.
            </summary>
        </member>
        <member name="M:Microsoft.ML.Data.ConsoleEnvironment.RedirectChannelOutput(System.IO.TextWriter,System.IO.TextWriter)">
            <summary>
            Redirects the channel output through the specified writers.
            </summary>
            <remarks>This method is not thread-safe.</remarks>
        </member>
        <member name="T:Microsoft.ML.Data.ChannelProviderBase">
            <summary>
            Base class for channel providers. This is a common base class for<see cref="T:Microsoft.ML.Data.HostEnvironmentBase`1"/>.
            The ParentFullName, ShortName, and FullName may be null or empty.
            </summary>
        </member>
        <member name="T:Microsoft.ML.Data.ChannelProviderBase.ExceptionContextKeys">
            <summary>
            Data keys that are attached to the exception thrown via the exception context.
            </summary>
        </member>
        <member name="P:Microsoft.ML.Data.ChannelProviderBase.Depth">
            <summary>
            The channel depth, NOT host env depth.
            </summary>
        </member>
        <member name="P:Microsoft.ML.Data.ChannelProviderBase.ContextDescription">
            <summary>
            ExceptionContext description.
            </summary>
        </member>
        <member name="M:Microsoft.ML.Data.ChannelProviderBase.GenerateFullName">
            <summary>
            Override this method to change the way full names are constructed.
            </summary>
        </member>
        <member name="T:Microsoft.ML.Data.IMessageSource">
            <summary>
            Message source (a channel) that generated the message being dispatched.
            </summary>
        </member>
        <member name="T:Microsoft.ML.Data.HostEnvironmentBase`1">
            <summary>
            A basic host environment suited for many environments.
            This also supports modifying the concurrency factor, provides the ability to subscribe to pipes via the
            AddListener/RemoveListener methods, and exposes the <see cref="T:Microsoft.ML.Data.ProgressReporting.ProgressTracker"/> to
            query progress.
            </summary>
        </member>
        <member name="T:Microsoft.ML.Data.HostEnvironmentBase`1.HostBase">
            <summary>
            Base class for hosts. Classes derived from  <see cref="T:Microsoft.ML.Data.HostEnvironmentBase`1"/> may choose
            to provide their own host class that derives from this class.
            This encapsulates the random number generator and name information.
            </summary>
        </member>
        <member name="T:Microsoft.ML.Data.HostEnvironmentBase`1.PipeBase`1">
            <summary>
            Base class for implementing <see cref="T:Microsoft.ML.IPipe`1"/>. Deriving classes can optionally override
            the Done() and the DisposeCore() methods. If no overrides are needed, the sealed class
            <see cref="T:Microsoft.ML.Data.HostEnvironmentBase`1.Pipe`1"/> may be used.
            </summary>
        </member>
        <member name="T:Microsoft.ML.Data.HostEnvironmentBase`1.ChannelBase">
            <summary>
            A base class for <see cref="T:Microsoft.ML.IChannel"/> implementations. A message is dispatched as a
            <see cref="T:Microsoft.ML.ChannelMessage"/>. Deriving classes can optionally override the Done() and the
            DisposeCore() methods.
            </summary>
        </member>
        <member name="T:Microsoft.ML.Data.HostEnvironmentBase`1.Pipe`1">
            <summary>
            An optional implementation of <see cref="T:Microsoft.ML.IPipe`1"/>.
            </summary>
        </member>
        <member name="T:Microsoft.ML.Data.HostEnvironmentBase`1.Dispatcher">
            <summary>
            Base class for <see cref="T:Microsoft.ML.Data.HostEnvironmentBase`1.Dispatcher`1"/>. The master host environment has a
            map from <see cref="T:System.Type"/> to <see cref="T:Microsoft.ML.Data.HostEnvironmentBase`1.Dispatcher"/>.
            </summary>
        </member>
        <member name="T:Microsoft.ML.Data.HostEnvironmentBase`1.Dispatcher`1">
            <summary>
            Strongly typed dispatcher class.
            </summary>
        </member>
        <member name="F:Microsoft.ML.Data.HostEnvironmentBase`1.Dispatcher`1._listenerAction">
             <summary>
             This field is actually used as a <see cref="T:System.MulticastDelegate"/>, which holds the listener actions
             for all listeners that are currently subscribed. The action itself is an immutable object, so every time
             any listener subscribes or unsubscribes, the field is replaced with a modified version of the delegate.
            
             The field can be null, if no listener is currently subscribed.
             </summary>
        </member>
        <member name="F:Microsoft.ML.Data.HostEnvironmentBase`1.Dispatcher`1._dispatch">
            <summary>
            The dispatch delegate invokes the current dispatching action (wchch calls all current listeners).
            </summary>
        </member>
        <member name="P:Microsoft.ML.Data.HostEnvironmentBase`1.ConcurrencyFactor">
            <summary>
            This host environment supports changing this value dynamically.
            </summary>
        </member>
        <member name="M:Microsoft.ML.Data.HostEnvironmentBase`1.#ctor(System.Random,System.Boolean,System.Int32,System.String,System.String)">
            <summary>
             The main constructor.
            </summary>
        </member>
        <member name="M:Microsoft.ML.Data.HostEnvironmentBase`1.#ctor(Microsoft.ML.Data.HostEnvironmentBase{`0},System.Random,System.Boolean,System.Nullable{System.Int32},System.String,System.String)">
            <summary>
            This constructor is for forking.
            </summary>
        </member>
        <member name="M:Microsoft.ML.Data.HostEnvironmentBase`1.EnsureDispatcher``1">
            <summary>
            This method is called when a channel is created and when a listener is registered.
            This method is not invoked on every message.
            </summary>
        </member>
        <member name="M:Microsoft.ML.Data.HostEnvironmentBase`1.PrintMessageNormalized(System.IO.TextWriter,System.String,System.Boolean,System.String)">
            <summary>
            Line endings in message may not be normalized, this method provides normalized printing.
            </summary>
            <param name="writer">The text writer to write to.</param>
            <param name="message">The message, which if it contains newlines will be normalized.</param>
            <param name="removeLastNewLine">If false, then two newlines will be printed at the end,
            making messages be bracketed by blank lines. If true then only the single newline at the
            end of a message is printed.</param>
            <param name="prefix">A prefix that will be written to every line, except the first line.
            If <paramref name="message"/> contains no newlines then this prefix will not be
            written at all. This prefix is not written to the newline written if
            <paramref name="removeLastNewLine"/> is false.</param>
        </member>
        <member name="T:Microsoft.ML.Command.SignatureCommand">
            <summary>
            The signature for commands.
            </summary>
        </member>
        <member name="T:Microsoft.ML.SchemaShape">
            <summary>
            A set of 'requirements' to the incoming schema, as well as a set of 'promises' of the outgoing schema.
            This is more relaxed than the proper <see cref="T:Microsoft.Data.DataView.DataViewSchema"/>, since it's only a subset of the columns,
            and also since it doesn't specify exact <see cref="T:Microsoft.Data.DataView.DataViewType"/>'s for vectors and keys.
            </summary>
        </member>
        <member name="F:Microsoft.ML.SchemaShape.Column.Name">
            <summary>
            The column name.
            </summary>
        </member>
        <member name="F:Microsoft.ML.SchemaShape.Column.Kind">
            <summary>
            The type of the column: scalar, fixed vector or variable vector.
            </summary>
        </member>
        <member name="F:Microsoft.ML.SchemaShape.Column.ItemType">
            <summary>
            The 'raw' type of column item: must be a primitive type or a structured type.
            </summary>
        </member>
        <member name="F:Microsoft.ML.SchemaShape.Column.IsKey">
            <summary>
            The flag whether the column is actually a key. If yes, <see cref="F:Microsoft.ML.SchemaShape.Column.ItemType"/> is representing
            the underlying primitive type.
            </summary>
        </member>
        <member name="F:Microsoft.ML.SchemaShape.Column.Annotations">
            <summary>
            The annotations that are present for this column.
            </summary>
        </member>
        <member name="M:Microsoft.ML.SchemaShape.Column.IsCompatibleWith(Microsoft.ML.SchemaShape.Column)">
             <summary>
             Returns whether <paramref name="source"/> is a valid input, if this object represents a
             requirement.
            
             Namely, it returns true iff:
              - The <see cref="F:Microsoft.ML.SchemaShape.Column.Name"/>, <see cref="F:Microsoft.ML.SchemaShape.Column.Kind"/>, <see cref="F:Microsoft.ML.SchemaShape.Column.ItemType"/>, <see cref="F:Microsoft.ML.SchemaShape.Column.IsKey"/> fields match.
              - The columns of <see cref="F:Microsoft.ML.SchemaShape.Column.Annotations"/> of <paramref name="source"/> is a superset of our <see cref="F:Microsoft.ML.SchemaShape.Column.Annotations"/> columns.
              - Each such annotation column is itself compatible with the input annotation column.
             </summary>
        </member>
        <member name="P:Microsoft.ML.SchemaShape.Column.IsValid">
            <summary>
            Return if this structure is not identical to the default value of <see cref="T:Microsoft.ML.SchemaShape.Column"/>. If true,
            it means this structure is initialized properly and therefore considered as valid.
            </summary>
        </member>
        <member name="M:Microsoft.ML.SchemaShape.GetColumnTypeShape(Microsoft.Data.DataView.DataViewType,Microsoft.ML.SchemaShape.Column.VectorKind@,Microsoft.Data.DataView.DataViewType@,System.Boolean@)">
            <summary>
            Given a <paramref name="type"/>, extract the type parameters that describe this type
            as a <see cref="T:Microsoft.ML.SchemaShape"/>'s column type.
            </summary>
            <param name="type">The actual column type to process.</param>
            <param name="vecKind">The vector kind of <paramref name="type"/>.</param>
            <param name="itemType">The item type of <paramref name="type"/>.</param>
            <param name="isKey">Whether <paramref name="type"/> (or its item type) is a key.</param>
        </member>
        <member name="M:Microsoft.ML.SchemaShape.Create(Microsoft.Data.DataView.DataViewSchema)">
            <summary>
            Create a schema shape out of the fully defined schema.
            </summary>
        </member>
        <member name="M:Microsoft.ML.SchemaShape.TryFindColumn(System.String,Microsoft.ML.SchemaShape.Column@)">
            <summary>
            Returns if there is a column with a specified <paramref name="name"/> and if so stores it in <paramref name="column"/>.
            </summary>
        </member>
        <member name="T:Microsoft.ML.IDataLoader`1">
            <summary>
            The 'data loader' takes a certain kind of input and turns it into an <see cref="T:Microsoft.Data.DataView.IDataView"/>.
            </summary>
            <typeparam name="TSource">The type of input the loader takes.</typeparam>
        </member>
        <member name="M:Microsoft.ML.IDataLoader`1.Load(`0)">
            <summary>
            Produce the data view from the specified input.
            Note that <see cref="T:Microsoft.Data.DataView.IDataView"/>'s are lazy, so no actual loading happens here, just schema validation.
            </summary>
        </member>
        <member name="M:Microsoft.ML.IDataLoader`1.GetOutputSchema">
            <summary>
            The output schema of the loader.
            </summary>
        </member>
        <member name="T:Microsoft.ML.IDataLoaderEstimator`2">
            <summary>
            Sometimes we need to 'fit' an <see cref="T:Microsoft.ML.IDataLoader`1"/>.
            A DataLoader estimator is the object that does it.
            </summary>
        </member>
        <member name="M:Microsoft.ML.IDataLoaderEstimator`2.Fit(`0)">
            <summary>
            Train and return a data loader.
            </summary>
        </member>
        <member name="M:Microsoft.ML.IDataLoaderEstimator`2.GetOutputSchema">
            <summary>
            The 'promise' of the output schema.
            It will be used for schema propagation.
            </summary>
        </member>
        <member name="T:Microsoft.ML.ITransformer">
            <summary>
            The transformer is a component that transforms data.
            It also supports 'schema propagation' to answer the question of 'how will the data with this schema look, after you transform it?'.
            </summary>
        </member>
        <member name="M:Microsoft.ML.ITransformer.GetOutputSchema(Microsoft.Data.DataView.DataViewSchema)">
            <summary>
            Schema propagation for transformers.
            Returns the output schema of the data, if the input schema is like the one provided.
            </summary>
        </member>
        <member name="M:Microsoft.ML.ITransformer.Transform(Microsoft.Data.DataView.IDataView)">
            <summary>
            Take the data in, make transformations, output the data.
            Note that <see cref="T:Microsoft.Data.DataView.IDataView"/>'s are lazy, so no actual transformations happen here, just schema validation.
            </summary>
        </member>
        <member name="P:Microsoft.ML.ITransformer.IsRowToRowMapper">
            <summary>
            Whether a call to <see cref="M:Microsoft.ML.ITransformer.GetRowToRowMapper(Microsoft.Data.DataView.DataViewSchema)"/> should succeed, on an
            appropriate schema.
            </summary>
        </member>
        <member name="M:Microsoft.ML.ITransformer.GetRowToRowMapper(Microsoft.Data.DataView.DataViewSchema)">
            <summary>
            Constructs a row-to-row mapper based on an input schema. If <see cref="P:Microsoft.ML.ITransformer.IsRowToRowMapper"/>
            is <c>false</c>, then an exception should be thrown. If the input schema is in any way
            unsuitable for constructing the mapper, an exception should likewise be thrown.
            </summary>
            <param name="inputSchema">The input schema for which we should get the mapper.</param>
            <returns>The row to row mapper.</returns>
        </member>
        <member name="T:Microsoft.ML.IEstimator`1">
            <summary>
            The estimator (in Spark terminology) is an 'untrained transformer'. It needs to 'fit' on the data to manufacture
            a transformer.
            It also provides the 'schema propagation' like transformers do, but over <see cref="T:Microsoft.ML.SchemaShape"/> instead of <see cref="T:Microsoft.Data.DataView.DataViewSchema"/>.
            </summary>
        </member>
        <member name="M:Microsoft.ML.IEstimator`1.Fit(Microsoft.Data.DataView.IDataView)">
            <summary>
            Train and return a transformer.
            </summary>
        </member>
        <member name="M:Microsoft.ML.IEstimator`1.GetOutputSchema(Microsoft.ML.SchemaShape)">
            <summary>
            Schema propagation for estimators.
            Returns the output schema shape of the estimator, if the input schema shape is like the one provided.
            </summary>
        </member>
        <member name="T:Microsoft.ML.IFileHandle">
            <summary>
            A file handle.
            </summary>
        </member>
        <member name="P:Microsoft.ML.IFileHandle.CanWrite">
            <summary>
            Returns whether CreateWriteStream is expected to succeed. Typically, once
            CreateWriteStream has been called once, this will forever more return false.
            </summary>
        </member>
        <member name="P:Microsoft.ML.IFileHandle.CanRead">
            <summary>
            Returns whether OpenReadStream is expected to succeed.
            </summary>
        </member>
        <member name="M:Microsoft.ML.IFileHandle.CreateWriteStream">
            <summary>
            Create a writable stream for this file handle.
            </summary>
        </member>
        <member name="M:Microsoft.ML.IFileHandle.OpenReadStream">
            <summary>
            Open a readable stream for this file handle.
            </summary>
        </member>
        <member name="T:Microsoft.ML.SimpleFileHandle">
            <summary>
            A simple disk-based file handle.
            </summary>
        </member>
        <member name="T:Microsoft.ML.IChannelProvider">
            <summary>
            A channel provider can create new channels and generic information pipes.
            </summary>
        </member>
        <member name="M:Microsoft.ML.IChannelProvider.Start(System.String)">
            <summary>
            Start a standard message channel.
            </summary>
        </member>
        <member name="M:Microsoft.ML.IChannelProvider.StartPipe``1(System.String)">
            <summary>
            Start a generic information pipe.
            </summary>
        </member>
        <member name="T:Microsoft.ML.HostEnvironmentExtensions">
            <summary>
            Utility class for IHostEnvironment
            </summary>
        </member>
        <member name="M:Microsoft.ML.HostEnvironmentExtensions.OpenInputFile(Microsoft.ML.IHostEnvironment,System.String)">
            <summary>
            Return a file handle for an input "file".
            </summary>
        </member>
        <member name="M:Microsoft.ML.HostEnvironmentExtensions.CreateOutputFile(Microsoft.ML.IHostEnvironment,System.String)">
            <summary>
            Create an output "file" and return a handle to it.
            </summary>
        </member>
        <member name="T:Microsoft.ML.IHostEnvironment">
            <summary>
            The host environment interface creates hosts for components. Note that the methods of
            this interface should be called from the main thread for the environment. To get an environment
            to service another thread, call Fork and pass the return result to that thread.
            </summary>
        </member>
        <member name="M:Microsoft.ML.IHostEnvironment.Register(System.String,System.Nullable{System.Int32},System.Nullable{System.Boolean},System.Nullable{System.Int32})">
            <summary>
            Create a host with the given registration name.
            </summary>
        </member>
        <member name="P:Microsoft.ML.IHostEnvironment.ConcurrencyFactor">
            <summary>
            How much concurrency the component should use. A value of 1 means
            single-threaded. Higher values generally mean number of threads. Less
            than 1 means whatever the component views as ideal.
            </summary>
        </member>
        <member name="P:Microsoft.ML.IHostEnvironment.IsCancelled">
            <summary>
            Flag which indicate should we stop any code execution in this host.
            </summary>
        </member>
        <member name="P:Microsoft.ML.IHostEnvironment.ComponentCatalog">
            <summary>
            The catalog of loadable components (<see cref="T:Microsoft.ML.LoadableClassAttribute"/>) that are available in this host.
            </summary>
        </member>
        <member name="T:Microsoft.ML.IHost">
            <summary>
            A host is coupled to a component and provides random number generation and concurrency guidance.
            Note that the random number generation, like the host environment methods, should be accessed only
            from the main thread for the component.
            </summary>
        </member>
        <member name="P:Microsoft.ML.IHost.Rand">
            <summary>
            The random number generator issued to this component. Note that random number
            generators are NOT thread safe.
            </summary>
        </member>
        <member name="M:Microsoft.ML.IHost.StopExecution">
            <summary>
            Signal to stop exection in this host and all its children.
            </summary>
        </member>
        <member name="T:Microsoft.ML.IPipe`1">
            <summary>
            A generic information pipe. Note that pipes are disposable. Generally, Done should
            be called before disposing to signal a normal shut-down of the pipe, as opposed
            to an aborted completion.
            </summary>
        </member>
        <member name="M:Microsoft.ML.IPipe`1.Send(`0)">
            <summary>
            The caller relinquishes ownership of the <paramref name="msg"/> object.
            </summary>
        </member>
        <member name="T:Microsoft.ML.ChannelMessageKind">
            <summary>
            The kinds of standard channel messages.
            Note: These values should never be changed. We can add new kinds, but don't change these values.
            Other code bases, including native code for other projects depends on these values.
            </summary>
        </member>
        <member name="T:Microsoft.ML.MessageSensitivity">
            <summary>
            A flag that can be attached to a message or exception to indicate that
            it has a certain class of sensitive data. By default, messages should be
            specified as being of unknown sensitivity, which is to say, every
            sensitivity flag is turned on, corresponding to <see cref="F:Microsoft.ML.MessageSensitivity.Unknown"/>.
            Messages that are totally safe should be marked as <see cref="F:Microsoft.ML.MessageSensitivity.None"/>.
            However, if, say, one prints out data from a file (for example, this might
            be done when expressing parse errors), it should be flagged in that case
            with <see cref="F:Microsoft.ML.MessageSensitivity.UserData"/>.
            </summary>
        </member>
        <member name="F:Microsoft.ML.MessageSensitivity.None">
            <summary>
            For non-sensitive data.
            </summary>
        </member>
        <member name="F:Microsoft.ML.MessageSensitivity.UserData">
            <summary>
            For messages that may contain user-data from data files.
            </summary>
        </member>
        <member name="F:Microsoft.ML.MessageSensitivity.Schema">
            <summary>
            For messages that contain information like column names from datasets.
            Note that, despite being part of the schema, annotations should be treated
            as user data, since it is often derived from user data. Note also that
            types, despite being part of the schema, are not considered "sensitive"
            as such, in the same way that column names might be.
            </summary>
        </member>
        <member name="F:Microsoft.ML.MessageSensitivity.Unknown">
            <summary>
            The default value, unknown, is treated as if everything is sensitive.
            </summary>
        </member>
        <member name="F:Microsoft.ML.MessageSensitivity.All">
            <summary>
            An alias for <see cref="F:Microsoft.ML.MessageSensitivity.Unknown"/>, so it is functionally the same, except
            semantically it communicates the idea that we want all bits set.
            </summary>
        </member>
        <member name="T:Microsoft.ML.ChannelMessage">
            <summary>
            A channel message.
            </summary>
        </member>
        <member name="P:Microsoft.ML.ChannelMessage.Message">
            <summary>
            Line endings may not be normalized.
            </summary>
        </member>
        <member name="T:Microsoft.ML.IChannel">
            <summary>
            A standard communication channel.
            </summary>
        </member>
        <member name="T:Microsoft.ML.HostExtensions">
            <summary>
            General utility extension methods for objects in the "host" universe, i.e.,
            <see cref="T:Microsoft.ML.IHostEnvironment"/>, <see cref="T:Microsoft.ML.IHost"/>, and <see cref="T:Microsoft.ML.IChannel"/>
            that do not belong in more specific areas, for example, <see cref="T:Microsoft.ML.Contracts"/> or
            component creation.
            </summary>
        </member>
        <member name="M:Microsoft.ML.HostExtensions.Trace(Microsoft.ML.IChannel,System.String)">
            <summary>
            Convenience variant of <see cref="M:Microsoft.ML.IChannel.Trace(Microsoft.ML.MessageSensitivity,System.String)"/>
            setting <see cref="F:Microsoft.ML.MessageSensitivity.Unknown"/>.
            </summary>
        </member>
        <member name="M:Microsoft.ML.HostExtensions.Trace(Microsoft.ML.IChannel,System.String,System.Object[])">
            <summary>
            Convenience variant of <see cref="M:Microsoft.ML.IChannel.Trace(Microsoft.ML.MessageSensitivity,System.String,System.Object[])"/>
            setting <see cref="F:Microsoft.ML.MessageSensitivity.Unknown"/>.
            </summary>
        </member>
        <member name="M:Microsoft.ML.HostExtensions.Error(Microsoft.ML.IChannel,System.String)">
            <summary>
            Convenience variant of <see cref="M:Microsoft.ML.IChannel.Error(Microsoft.ML.MessageSensitivity,System.String)"/>
            setting <see cref="F:Microsoft.ML.MessageSensitivity.Unknown"/>.
            </summary>
        </member>
        <member name="M:Microsoft.ML.HostExtensions.Error(Microsoft.ML.IChannel,System.String,System.Object[])">
            <summary>
            Convenience variant of <see cref="M:Microsoft.ML.IChannel.Error(Microsoft.ML.MessageSensitivity,System.String,System.Object[])"/>
            setting <see cref="F:Microsoft.ML.MessageSensitivity.Unknown"/>.
            </summary>
        </member>
        <member name="M:Microsoft.ML.HostExtensions.Warning(Microsoft.ML.IChannel,System.String)">
            <summary>
            Convenience variant of <see cref="M:Microsoft.ML.IChannel.Warning(Microsoft.ML.MessageSensitivity,System.String)"/>
            setting <see cref="F:Microsoft.ML.MessageSensitivity.Unknown"/>.
            </summary>
        </member>
        <member name="M:Microsoft.ML.HostExtensions.Warning(Microsoft.ML.IChannel,System.String,System.Object[])">
            <summary>
            Convenience variant of <see cref="M:Microsoft.ML.IChannel.Warning(Microsoft.ML.MessageSensitivity,System.String,System.Object[])"/>
            setting <see cref="F:Microsoft.ML.MessageSensitivity.Unknown"/>.
            </summary>
        </member>
        <member name="M:Microsoft.ML.HostExtensions.Info(Microsoft.ML.IChannel,System.String)">
            <summary>
            Convenience variant of <see cref="M:Microsoft.ML.IChannel.Info(Microsoft.ML.MessageSensitivity,System.String)"/>
            setting <see cref="F:Microsoft.ML.MessageSensitivity.Unknown"/>.
            </summary>
        </member>
        <member name="M:Microsoft.ML.HostExtensions.Info(Microsoft.ML.IChannel,System.String,System.Object[])">
            <summary>
            Convenience variant of <see cref="M:Microsoft.ML.IChannel.Info(Microsoft.ML.MessageSensitivity,System.String,System.Object[])"/>
            setting <see cref="F:Microsoft.ML.MessageSensitivity.Unknown"/>.
            </summary>
        </member>
        <member name="T:Microsoft.ML.IProgressChannelProvider">
             <summary>
             This is a factory interface for <see cref="T:Microsoft.ML.IProgressChannel"/>.
             Both <see cref="T:Microsoft.ML.IHostEnvironment"/> and <see cref="T:Microsoft.ML.IProgressChannel"/> implement this interface,
             to allow for nested progress reporters.
            
             REVIEW: make <see cref="T:Microsoft.ML.IChannelProvider"/> implement this, instead of the environment?
             </summary>
        </member>
        <member name="M:Microsoft.ML.IProgressChannelProvider.StartProgressChannel(System.String)">
            <summary>
            Create a progress channel for a computation named <paramref name="name"/>.
            </summary>
        </member>
        <member name="T:Microsoft.ML.IProgressChannel">
             <summary>
             A common interface for progress reporting.
             It is expected that the progress channel interface is used from only one thread.
            
             Supported workflow:
             1) Create the channel via <see cref="M:Microsoft.ML.IProgressChannelProvider.StartProgressChannel(System.String)"/>.
             2) Call <see cref="M:Microsoft.ML.IProgressChannel.SetHeader(Microsoft.ML.ProgressHeader,System.Action{Microsoft.ML.IProgressEntry})"/> as many times as desired (including 0).
                   Each call to <see cref="M:Microsoft.ML.IProgressChannel.SetHeader(Microsoft.ML.ProgressHeader,System.Action{Microsoft.ML.IProgressEntry})"/> supersedes the previous one.
             3) Report checkpoints (0 or more) by calling <see cref="M:Microsoft.ML.IProgressChannel.Checkpoint(System.Nullable{System.Double}[])"/>.
             4) Repeat steps 2-3 as often as necessary.
             5) Dispose the channel.
             </summary>
        </member>
        <member name="M:Microsoft.ML.IProgressChannel.SetHeader(Microsoft.ML.ProgressHeader,System.Action{Microsoft.ML.IProgressEntry})">
             <summary>
             Set up the reporting structure:
             - Set the 'header' of the progress reports, defining which progress units and metrics are going to be reported.
             - Provide a thread-safe delegate to be invoked whenever anyone needs to know the progress.
            
             It is acceptable to call <see cref="M:Microsoft.ML.IProgressChannel.SetHeader(Microsoft.ML.ProgressHeader,System.Action{Microsoft.ML.IProgressEntry})"/> multiple times (or none), regardless of whether the calculation is running
             or not. Because of synchronization, the computation should not deny calls to the 'old' <paramref name="fillAction"/>
             delegates even after a new one is provided.
             </summary>
             <param name="header">The header object.</param>
             <param name="fillAction">The delegate to provide actual progress. The <see cref="T:Microsoft.ML.IProgressEntry"/> parameter of
             the delegate will correspond to the provided <paramref name="header"/>.</param>
        </member>
        <member name="M:Microsoft.ML.IProgressChannel.Checkpoint(System.Nullable{System.Double}[])">
             <summary>
             Submit a 'checkpoint' entry. These entries are guaranteed to be delivered to the progress listener,
             if it is interested. Typically, this would contain some intermediate metrics, that are only calculated
             at certain moments ('checkpoints') of the computation.
            
             For example, SDCA may report a checkpoint every time it computes the loss, or LBFGS may report a checkpoint
             every iteration.
            
             The only parameter, <paramref name="values"/>, is interpreted in the following fashion:
             * First MetricNames.Length items, if present, are metrics.
             * Subsequent ProgressNames.Length items, if present, are progress units.
             * Subsequent ProgressNames.Length items, if present, are progress limits.
             * If any more values remain, an exception is thrown.
             </summary>
             <param name="values">The metrics, progress units and progress limits.</param>
        </member>
        <member name="T:Microsoft.ML.ProgressHeader">
            <summary>
            This is the 'header' of the progress report.
            </summary>
        </member>
        <member name="F:Microsoft.ML.ProgressHeader.UnitNames">
            <summary>
            These are the names of the progress 'units', from the least granular to the most granular.
            For example, neural network might have {'epoch', 'example'} and FastTree might have {'tree', 'split', 'feature'}.
            Will never be null, but can be empty.
            </summary>
        </member>
        <member name="F:Microsoft.ML.ProgressHeader.MetricNames">
            <summary>
            These are the names of the reported metrics. For example, this could be the 'loss', 'weight updates/sec' etc.
            Will never be null, but can be empty.
            </summary>
        </member>
        <member name="M:Microsoft.ML.ProgressHeader.#ctor(System.String[],System.String[])">
            <summary>
            Initialize the header. This will take ownership of the arrays.
            Both arrays can be null, even simultaneously. This 'empty' header indicated that the calculation doesn't report
            any units of progress, but the tracker can still track start, stop and elapsed time. Of course, if there's any
            progress or metrics to report, it is always better to report them.
            </summary>
            <param name="metricNames">The metrics that the calculation reports. These are completely independent, and there
            is no contract on whether the metric values should increase or not. As naming convention, <paramref name="metricNames"/>
            can have multiple words with spaces, and should be title-cased.</param>
            <param name="unitNames">The names of the progress units, listed from least granular to most granular.
            The idea is that the progress should be lexicographically increasing (like [0,0], [0,10], [1,0], [1,15], [2,5] etc.).
            As naming convention, <paramref name="unitNames"/> should be lower-cased and typically plural
            (for example, iterations, clusters, examples). </param>
        </member>
        <member name="M:Microsoft.ML.ProgressHeader.#ctor(System.String[])">
            <summary>
            A constructor for no metrics, just progress units. As naming convention, <paramref name="unitNames"/> should be lower-cased
            and typically plural (for example, iterations, clusters, examples).
            </summary>
        </member>
        <member name="T:Microsoft.ML.IProgressEntry">
            <summary>
            A metric/progress holder item.
            </summary>
        </member>
        <member name="M:Microsoft.ML.IProgressEntry.SetProgress(System.Int32,System.Double)">
            <summary>
            Set the progress value for the index <paramref name="index"/> to <paramref name="value"/>,
            and the limit value for the progress becomes 'unknown'.
            </summary>
        </member>
        <member name="M:Microsoft.ML.IProgressEntry.SetProgress(System.Int32,System.Double,System.Double)">
            <summary>
            Set the progress value for the index <paramref name="index"/> to <paramref name="value"/>,
            and the limit value to <paramref name="lim"/>. If <paramref name="lim"/> is a NAN, it is set to null instead.
            </summary>
        </member>
        <member name="M:Microsoft.ML.IProgressEntry.SetMetric(System.Int32,System.Double)">
            <summary>
            Sets the metric with index <paramref name="index"/> to <paramref name="value"/>.
            </summary>
        </member>
        <member name="F:Microsoft.ML.ModelHeader.SignatureValue">
            <summary>
            This spells 'ML MODEL' with zero replacing space (assuming little endian).
            </summary>
        </member>
        <member name="M:Microsoft.ML.ModelHeader.BeginWrite(System.IO.BinaryWriter,System.Int64@,Microsoft.ML.ModelHeader@)">
            <summary>
            Initialize the header and writer for writing. The value of fpMin and header
            should be passed to the other utility methods here.
            </summary>
        </member>
        <member name="M:Microsoft.ML.ModelHeader.EndWrite(System.IO.BinaryWriter,System.Int64,Microsoft.ML.ModelHeader@,Microsoft.ML.Internal.Utilities.NormStr.Pool,System.String)">
            <summary>
            The current writer position should be the end of the model blob. Records the model size, writes the string table,
            completes and writes the header, and writes the tail.
            </summary>
        </member>
        <member name="M:Microsoft.ML.ModelHeader.WriteHeaderAndTailCore(System.IO.BinaryWriter,System.Int64,Microsoft.ML.ModelHeader@)">
            <summary>
            The current writer position should be where the tail belongs. Writes the header and tail.
            Typically this isn't called directly unless you are doing custom string table serialization.
            In that case you should have called EndModelCore before writing the string table information.
            </summary>
        </member>
        <member name="M:Microsoft.ML.ModelHeader.EndModelCore(System.IO.BinaryWriter,System.Int64,Microsoft.ML.ModelHeader@)">
            <summary>
            The current writer position should be the end of the model blob. Records the size of the model blob.
            Typically this isn't called directly unless you are doing custom string table serialization.
            </summary>
        </member>
        <member name="M:Microsoft.ML.ModelHeader.SetVersionInfo(Microsoft.ML.ModelHeader@,Microsoft.ML.VersionInfo)">
            <summary>
            Sets the version information the header.
            </summary>
        </member>
        <member name="M:Microsoft.ML.ModelHeader.SetLoaderSig(Microsoft.ML.ModelHeader@,System.String)">
            <summary>
            Record the given loader sig in the header. If sig is null, clears the loader sig.
            </summary>
        </member>
        <member name="M:Microsoft.ML.ModelHeader.SetLoaderSigAlt(Microsoft.ML.ModelHeader@,System.String)">
            <summary>
            Record the given alternate loader sig in the header. If sig is null, clears the alternate loader sig.
            </summary>
        </member>
        <member name="M:Microsoft.ML.ModelHeader.MarshalToBytes(Microsoft.ML.ModelHeader@,System.Byte[])">
            <summary>
            Low level method for copying bytes from a header structure into a byte array.
            </summary>
        </member>
        <member name="M:Microsoft.ML.ModelHeader.BeginRead(System.Int64@,Microsoft.ML.ModelHeader@,System.String[]@,System.String@,System.IO.BinaryReader)">
            <summary>
            Read the model header, strings, etc from reader. Also validates the header (throws if bad).
            Leaves the reader position at the beginning of the model blob.
            </summary>
        </member>
        <member name="M:Microsoft.ML.ModelHeader.EndRead(System.Int64,Microsoft.ML.ModelHeader@,System.IO.BinaryReader)">
            <summary>
            Finish reading. Checks that the current reader position is the end of the model blob.
            Seeks to the end of the entire model file (after the tail).
            </summary>
        </member>
        <member name="M:Microsoft.ML.ModelHeader.CheckVersionInfo(Microsoft.ML.ModelHeader@,Microsoft.ML.VersionInfo)">
            <summary>
            Performs standard version validation.
            </summary>
        </member>
        <member name="M:Microsoft.ML.ModelHeader.MarshalFromBytes(Microsoft.ML.ModelHeader@,System.Byte[])">
            <summary>
            Low level method for copying bytes from a byte array to a header structure.
            </summary>
        </member>
        <member name="M:Microsoft.ML.ModelHeader.TryValidate(Microsoft.ML.ModelHeader@,System.Int64,System.Exception@)">
            <summary>
            Checks the basic validity of the header, assuming the stream is at least the given size.
            Returns false (and the out exception) on failure.
            </summary>
        </member>
        <member name="M:Microsoft.ML.ModelHeader.TryValidate(Microsoft.ML.ModelHeader@,System.IO.BinaryReader,System.Int64,System.String[]@,System.String@,System.Exception@)">
            <summary>
            Checks the validity of the header, reads the string table, etc.
            </summary>
        </member>
        <member name="M:Microsoft.ML.ModelHeader.GetLoaderSig(Microsoft.ML.ModelHeader@)">
            <summary>
            Extract and return the loader sig from the header, trimming trailing zeros.
            </summary>
        </member>
        <member name="M:Microsoft.ML.ModelHeader.GetLoaderSigAlt(Microsoft.ML.ModelHeader@)">
            <summary>
            Extract and return the alternate loader sig from the header, trimming trailing zeros.
            </summary>
        </member>
        <member name="T:Microsoft.ML.VersionInfo">
            <summary>
            This is used to simplify version checking boiler-plate code. It is an optional
            utility type.
            </summary>
        </member>
        <member name="M:Microsoft.ML.VersionInfo.#ctor(System.String,System.UInt32,System.UInt32,System.UInt32,System.String,System.String,System.String)">
            <summary>
            Construct version info with a string value for modelSignature. The string must be 8 characters
            all less than 0x100. Spaces are mapped to zero. This assumes little-endian.
            </summary>
        </member>
        <member name="T:Microsoft.ML.ModelLoadContext">
            <summary>
            This is a convenience context object for loading models from a repository, for
            implementors of ICanSaveModel. It is not mandated but designed to reduce the
            amount of boiler plate code. It can also be used when loading from a single stream,
            for implementors of ICanSaveInBinaryFormat.
            </summary>
        </member>
        <member name="F:Microsoft.ML.ModelLoadContext.Repository">
            <summary>
            When in repository mode, this is the repository we're reading from. It is null when
            in single-stream mode.
            </summary>
        </member>
        <member name="F:Microsoft.ML.ModelLoadContext.Directory">
            <summary>
            When in repository mode, this is the direcory we're reading from. Null means the root
            of the repository. It is always null in single-stream mode.
            </summary>
        </member>
        <member name="F:Microsoft.ML.ModelLoadContext.Reader">
            <summary>
            The main stream reader.
            </summary>
        </member>
        <member name="F:Microsoft.ML.ModelLoadContext.Strings">
            <summary>
            The strings loaded from the main stream's string table.
            </summary>
        </member>
        <member name="F:Microsoft.ML.ModelLoadContext.LoaderAssemblyName">
            <summary>
            The name of the assembly that the loader lives in.
            </summary>
            <remarks>
            This may be null or empty if one was never written to the model, or is an older model version.
            </remarks>
        </member>
        <member name="F:Microsoft.ML.ModelLoadContext.Header">
            <summary>
            The main stream's model header.
            </summary>
        </member>
        <member name="F:Microsoft.ML.ModelLoadContext.FpMin">
            <summary>
            The min file position of the main stream.
            </summary>
        </member>
        <member name="F:Microsoft.ML.ModelLoadContext._ectx">
            <summary>
            Exception context provided by Repository (can be null).
            </summary>
        </member>
        <member name="P:Microsoft.ML.ModelLoadContext.InRepository">
            <summary>
            Returns whether this context is in repository mode (true) or single-stream mode (false).
            </summary>
        </member>
        <member name="M:Microsoft.ML.ModelLoadContext.#ctor(Microsoft.ML.RepositoryReader,Microsoft.ML.Repository.Entry,System.String)">
            <summary>
            Create a ModelLoadContext supporting loading from a repository, for implementors of ICanSaveModel.
            </summary>
        </member>
        <member name="M:Microsoft.ML.ModelLoadContext.#ctor(System.IO.BinaryReader,Microsoft.ML.IExceptionContext)">
            <summary>
            Create a ModelLoadContext supporting loading from a single-stream, for implementors of ICanSaveInBinaryFormat.
            </summary>
        </member>
        <member name="M:Microsoft.ML.ModelLoadContext.CheckVersionInfo(Microsoft.ML.VersionInfo)">
            <summary>
            Performs version checks.
            </summary>
        </member>
        <member name="M:Microsoft.ML.ModelLoadContext.LoadStringOrNull">
            <summary>
            Reads an integer from the load context's reader, and returns the associated string,
            or null (encoded as -1).
            </summary>
        </member>
        <member name="M:Microsoft.ML.ModelLoadContext.LoadString">
            <summary>
            Reads an integer from the load context's reader, and returns the associated string.
            </summary>
        </member>
        <member name="M:Microsoft.ML.ModelLoadContext.LoadNonEmptyString">
            <summary>
            Reads an integer from the load context's reader, and returns the associated string.
            Throws if the string is empty or null.
            </summary>
        </member>
        <member name="M:Microsoft.ML.ModelLoadContext.Done">
            <summary>
            Commit the load operation. This completes reading of the main stream. When in repository
            mode, it disposes the Reader (but not the repository).
            </summary>
        </member>
        <member name="M:Microsoft.ML.ModelLoadContext.Dispose">
            <summary>
            When in repository mode, this disposes the Reader (but no the repository).
            </summary>
        </member>
        <member name="M:Microsoft.ML.ModelLoadContext.ContainsModel(System.String)">
            <summary>
            Return whether this context contains a directory and stream for a sub-model with
            the indicated name. This does not attempt to load the sub-model.
            </summary>
        </member>
        <member name="M:Microsoft.ML.ModelLoadContext.LoadModelOrNull``2(Microsoft.ML.IHostEnvironment,``0@,Microsoft.ML.RepositoryReader,System.String,System.Object[])">
            <summary>
            Load an optional object from the repository directory.
            Returns false iff no stream was found for the object, iff result is set to null.
            Throws if loading fails for any other reason.
            </summary>
        </member>
        <member name="M:Microsoft.ML.ModelLoadContext.LoadModel``2(Microsoft.ML.IHostEnvironment,``0@,Microsoft.ML.RepositoryReader,System.String,System.Object[])">
            <summary>
            Load an object from the repository directory.
            </summary>
        </member>
        <member name="M:Microsoft.ML.ModelLoadContext.LoadModelOrNull``2(Microsoft.ML.IHostEnvironment,``0@,System.String,System.Object[])">
            <summary>
            Load a sub model from the given sub directory if it exists. This requires InRepository to be true.
            Returns false iff no stream was found for the object, iff result is set to null.
            Throws if loading fails for any other reason.
            </summary>
        </member>
        <member name="M:Microsoft.ML.ModelLoadContext.LoadModel``2(Microsoft.ML.IHostEnvironment,``0@,System.String,System.Object[])">
            <summary>
            Load a sub model from the given sub directory. This requires InRepository to be true.
            </summary>
        </member>
        <member name="M:Microsoft.ML.ModelLoadContext.TryLoadModel``2(Microsoft.ML.IHostEnvironment,``0@,Microsoft.ML.RepositoryReader,Microsoft.ML.Repository.Entry,System.String,System.Object[])">
            <summary>
            Try to load from the given repository entry using the default loader(s) specified in the header.
            Returns false iff the default loader(s) could not be bound to a compatible loadable class.
            </summary>
        </member>
        <member name="M:Microsoft.ML.ModelLoadContext.LoadModel``2(Microsoft.ML.IHostEnvironment,``0@,Microsoft.ML.RepositoryReader,Microsoft.ML.Repository.Entry,System.String,System.Object[])">
            <summary>
            Load from the given repository entry using the default loader(s) specified in the header.
            </summary>
        </member>
        <member name="M:Microsoft.ML.ModelLoadContext.TryLoadModel``2(Microsoft.ML.IHostEnvironment,``0@,System.IO.Stream,System.Object[])">
            <summary>
            Try to load from the given stream (non-Repository).
            Returns false iff the default loader(s) could not be bound to a compatible loadable class.
            </summary>
        </member>
        <member name="M:Microsoft.ML.ModelLoadContext.LoadModel``2(Microsoft.ML.IHostEnvironment,``0@,System.IO.Stream,System.Object[])">
            <summary>
            Load from the given stream (non-Repository) using the default loader(s) specified in the header.
            </summary>
        </member>
        <member name="M:Microsoft.ML.ModelLoadContext.TryLoadModel``2(Microsoft.ML.IHostEnvironment,``0@,System.IO.BinaryReader,System.Object[])">
            <summary>
            Try to load from the given reader (non-Repository).
            Returns false iff the default loader(s) could not be bound to a compatible loadable class.
            </summary>
        </member>
        <member name="M:Microsoft.ML.ModelLoadContext.LoadModel``2(Microsoft.ML.IHostEnvironment,``0@,System.IO.BinaryReader,System.Object[])">
            <summary>
            Load from the given reader (non-Repository) using the default loader(s) specified in the header.
            </summary>
        </member>
        <member name="M:Microsoft.ML.ModelLoadContext.TryLoadModelCore``2(Microsoft.ML.IHostEnvironment,``0@,System.Object[])">
            <summary>
            Tries to load.
            Returns false iff the default loader(s) could not be bound to a compatible loadable class.
            </summary>
        </member>
        <member name="M:Microsoft.ML.ModelLoadContext.TryProcessSubModel(System.String,System.Action{Microsoft.ML.ModelLoadContext})">
            <summary>
            Try to load a sub model from the given sub directory. This requires InRepository to be true.
            </summary>
        </member>
        <member name="M:Microsoft.ML.ModelLoadContext.TryLoadBinaryStream(System.String,System.Action{System.IO.BinaryReader})">
            <summary>
            Try to load a binary stream from the current directory. This requires InRepository to be true.
            </summary>
        </member>
        <member name="M:Microsoft.ML.ModelLoadContext.TryLoadTextStream(System.String,System.Action{System.IO.TextReader})">
            <summary>
            Try to load a text stream from the current directory. This requires InRepository to be true.
            </summary>
        </member>
        <member name="T:Microsoft.ML.SignatureLoadModel">
            <summary>
            Signature for a repository based model loader. This is the dual of <see cref="T:Microsoft.ML.ICanSaveModel"/>.
            </summary>
        </member>
        <member name="T:Microsoft.ML.ModelSaveContext">
            <summary>
            This is a convenience context object for saving models to a repository, for
            implementors of <see cref="T:Microsoft.ML.ICanSaveModel"/>. It is not mandated but designed to reduce the
            amount of boiler plate code. It can also be used when saving to a single stream,
            for implementors of <see cref="T:Microsoft.ML.ICanSaveInBinaryFormat"/>.
            </summary>
        </member>
        <member name="F:Microsoft.ML.ModelSaveContext.Repository">
            <summary>
            When in repository mode, this is the repository we're writing to. It is null when
            in single-stream mode.
            </summary>
        </member>
        <member name="F:Microsoft.ML.ModelSaveContext.Directory">
            <summary>
            When in repository mode, this is the directory we're reading from. Null means the root
            of the repository. It is always null in single-stream mode.
            </summary>
        </member>
        <member name="F:Microsoft.ML.ModelSaveContext.Writer">
            <summary>
            The main stream writer.
            </summary>
        </member>
        <member name="F:Microsoft.ML.ModelSaveContext.Strings">
            <summary>
            The strings that will be saved in the main stream's string table.
            </summary>
        </member>
        <member name="F:Microsoft.ML.ModelSaveContext.Header">
            <summary>
            The main stream's model header.
            </summary>
        </member>
        <member name="F:Microsoft.ML.ModelSaveContext.FpMin">
            <summary>
            The min file position of the main stream.
            </summary>
        </member>
        <member name="F:Microsoft.ML.ModelSaveContext._ent">
            <summary>
            The wrapped entry.
            </summary>
        </member>
        <member name="F:Microsoft.ML.ModelSaveContext._ectx">
            <summary>
            Exception context provided by Repository (can be null).
            </summary>
        </member>
        <member name="F:Microsoft.ML.ModelSaveContext._loaderAssemblyName">
            <summary>
            The assembly name where the loader resides.
            </summary>
        </member>
        <member name="P:Microsoft.ML.ModelSaveContext.InRepository">
            <summary>
            Returns whether this context is in repository mode (true) or single-stream mode (false).
            </summary>
        </member>
        <member name="M:Microsoft.ML.ModelSaveContext.#ctor(Microsoft.ML.RepositoryWriter,System.String,System.String)">
            <summary>
            Create a <see cref="T:Microsoft.ML.ModelSaveContext"/> supporting saving to a repository, for implementors of <see cref="T:Microsoft.ML.ICanSaveModel"/>.
            </summary>
        </member>
        <member name="M:Microsoft.ML.ModelSaveContext.#ctor(System.IO.BinaryWriter,Microsoft.ML.IExceptionContext)">
            <summary>
            Create a <see cref="T:Microsoft.ML.ModelSaveContext"/> supporting saving to a single-stream, for implementors of <see cref="T:Microsoft.ML.ICanSaveInBinaryFormat"/>.
            </summary>
        </member>
        <member name="M:Microsoft.ML.ModelSaveContext.SetVersionInfo(Microsoft.ML.VersionInfo)">
            <summary>
            Set the version information in the main stream's header. This should be called before
            <see cref="M:Microsoft.ML.ModelSaveContext.Done"/> is called.
            </summary>
            <param name="ver"></param>
        </member>
        <member name="M:Microsoft.ML.ModelSaveContext.SaveStringOrNull(System.String)">
            <summary>
            Puts a string into the context pool, and writes the integer code of the string ID
            to the write stream. If str is null, this writes -1 and doesn't add it to the pool.
            </summary>
        </member>
        <member name="M:Microsoft.ML.ModelSaveContext.SaveString(System.String)">
            <summary>
            Puts a string into the context pool, and writes the integer code of the string ID
            to the write stream. Checks that str is not null.
            </summary>
        </member>
        <member name="M:Microsoft.ML.ModelSaveContext.SaveNonEmptyString(System.String)">
            <summary>
            Puts a string into the context pool, and writes the integer code of the string ID
            to the write stream.
            </summary>
        </member>
        <member name="M:Microsoft.ML.ModelSaveContext.Done">
            <summary>
            Commit the save operation. This completes writing of the main stream. When in repository
            mode, it disposes <see cref="F:Microsoft.ML.ModelSaveContext.Writer"/> (but not <see cref="F:Microsoft.ML.ModelSaveContext.Repository"/>).
            </summary>
        </member>
        <member name="M:Microsoft.ML.ModelSaveContext.Dispose">
            <summary>
            When in repository mode, this disposes the Writer (but not the repository).
            </summary>
        </member>
        <member name="M:Microsoft.ML.ModelSaveContext.SaveModel``1(``0,System.String)">
            <summary>
            Save a sub model to the given sub directory. This requires <see cref="P:Microsoft.ML.ModelSaveContext.InRepository"/> to be <see langword="true"/>.
            </summary>
        </member>
        <member name="M:Microsoft.ML.ModelSaveContext.SaveModel``1(Microsoft.ML.RepositoryWriter,``0,System.String)">
            <summary>
            Save the object by calling TrySaveModel then falling back to .net serialization.
            </summary>
        </member>
        <member name="M:Microsoft.ML.ModelSaveContext.Save(System.IO.BinaryWriter,System.Action{Microsoft.ML.ModelSaveContext})">
            <summary>
            Save to a single-stream by invoking the given action.
            </summary>
        </member>
        <member name="M:Microsoft.ML.ModelSaveContext.SaveSubModel(System.String,System.Action{Microsoft.ML.ModelSaveContext})">
            <summary>
            Save to the given sub directory by invoking the given action. This requires
            <see cref="P:Microsoft.ML.ModelSaveContext.InRepository"/> to be <see langword="true"/>.
            </summary>
        </member>
        <member name="T:Microsoft.ML.ICanSaveModel">
            <summary>
            For saving a model into a repository.
            Classes implementing <see cref="T:Microsoft.ML.ICanSaveModel"/> should do an explicit implementation of <see cref="M:Microsoft.ML.ICanSaveModel.Save(Microsoft.ML.ModelSaveContext)"/>.
            Classes inheriting <see cref="T:Microsoft.ML.ICanSaveModel"/> from a base class should overwrite the function invoked by <see cref="M:Microsoft.ML.ICanSaveModel.Save(Microsoft.ML.ModelSaveContext)"/>
            in that base class, if there is one.
            </summary>
        </member>
        <member name="T:Microsoft.ML.ICanSaveInBinaryFormat">
            <summary>
            For saving to a single stream. Note that this interface is mostly deprecated in favor of
            saving more comprehensive and composable "model" objects, via <see cref="T:Microsoft.ML.ICanSaveModel"/>.
            </summary>
        </member>
        <member name="T:Microsoft.ML.Repository">
            <summary>
            Abstraction around a <see cref="T:System.IO.Compression.ZipArchive"/> or other hierarchical storage.
            </summary>
        </member>
        <member name="P:Microsoft.ML.Repository.Entry.Path">
            <summary>
            The relative path of this entry.
            /// </summary>
        </member>
        <member name="P:Microsoft.ML.Repository.Entry.Stream">
            <summary>
            The stream for this entry. This is either a memory stream or a file stream in
            the temporary directory. In either case, it is seekable and NOT the actual
            archive stream.
            </summary>
        </member>
        <member name="P:Microsoft.ML.Repository.ExceptionContext">
            <summary>
            Exception context.
            </summary>
        </member>
        <member name="M:Microsoft.ML.Repository.DisposeAllEntries">
            <summary>
            Force all open entries to be disposed.
            </summary>
        </member>
        <member name="M:Microsoft.ML.Repository.RemoveEntry(Microsoft.ML.Repository.Entry)">
            <summary>
            Remove the entry from _open. Note that under normal access patterns, entries are LIFO,
            so we search from the end of _open.
            </summary>
        </member>
        <member name="M:Microsoft.ML.Repository.OnDispose(Microsoft.ML.Repository.Entry)">
            <summary>
            The entry is being disposed. Note that overrides should always call RemoveEntry, in addition to whatever
            they need to do with the corresponding stream.
            </summary>
        </member>
        <member name="M:Microsoft.ML.Repository.NormalizeForArchiveEntry(System.String)">
            <summary>
            When considering entries inside one of our model archives, we want to ensure that we
            use a consistent directory separator. Zip archives are stored as flat lists of entries.
            When we load those entries into our look-up dictionary, we normalize them to always use
            backward slashes.
            </summary>
        </member>
        <member name="M:Microsoft.ML.Repository.NormalizeForFileSystem(System.String)">
            <summary>
            When building paths to our local file system, we want to force both forward and backward slashes
            to the system directory separator character. We do this for cases where we either used Windows-specific
            path building logic, or concatenated filesystem paths with zip archive entries on Linux.
            </summary>
        </member>
        <member name="M:Microsoft.ML.Repository.GetPath(System.String@,System.String@,System.String,System.String,System.Boolean)">
            <summary>
            Constructs both the relative path to the entry and the absolute path of a corresponding
            temporary file. If createDir is true, makes sure the directory exists within the temp directory.
            </summary>
        </member>
        <member name="M:Microsoft.ML.RepositoryWriter.Commit">
            <summary>
            Commit the writing of the repository. This signals successful completion of the write.
            </summary>
        </member>
        <member name="T:Microsoft.ML.ServerChannel">
            <summary>
            Instances of this class are used to set up a bundle of named delegates. These
            delegates are registered through <see cref="M:Microsoft.ML.ServerChannel.Register``1(System.String,System.Func{``0})"/> and its overloads.
            Once all registrations are done, <see cref="M:Microsoft.ML.ServerChannel.Publish"/> is called and a message
            of type <see cref="T:Microsoft.ML.ServerChannel.Bundle"/> is sent through the input channel
            provider. The intended use case is that any information surfaced through these
            delegates will be published in some fashion, with the target scenario being
            that the library will publish some sort of restful API.
            </summary>
        </member>
        <member name="P:Microsoft.ML.ServerChannel.ThisIfActiveOrNull">
            <summary>
            Returns either this object, or <c>null</c> if there are no listeners on this server
            channel. This can be used in conjunction with the <c>?.</c> operator to have more
            performant though more robust calls to <see cref="M:Microsoft.ML.ServerChannel.Register``1(System.String,System.Func{``0})"/> and
            <see cref="M:Microsoft.ML.ServerChannel.Publish"/>.
            </summary>
        </member>
        <member name="M:Microsoft.ML.ServerChannel.Start(Microsoft.ML.IChannelProvider,System.String)">
            <summary>
            Starts a new server channel.
            </summary>
            <param name="provider">The channel provider, on which to send
            the notification that a server is being constructed</param>
            <param name="identifier">A semi-unique identifier for this
            "bundle" that is being constructed</param>
            <returns>The constructed server channel, or <c>null</c> if there
            was no listeners for server channels registered on <paramref name="provider"/></returns>
        </member>
        <member name="M:Microsoft.ML.ServerChannel.Publish">
            <summary>
            Finalizes all registrations of delegates, and pipes the bundle of objects
            in a <see cref="T:Microsoft.ML.ServerChannel.Bundle"/> up through the pipe to be consumed by any
            listeners.
            </summary>
        </member>
        <member name="T:Microsoft.ML.ServerChannel.IServerFactory">
            <summary>
            Entry point factory for creating <see cref="T:Microsoft.ML.ServerChannel.IServer"/> instances.
            </summary>
        </member>
        <member name="T:Microsoft.ML.ServerChannel.IServer">
             <summary>
             Classes that want to publish the bundles from server channels in some fashion should implement
             this interface. The intended simple use case is that this will be some form of in-process web
             server, and then when disposed, they should stop themselves.
            
             Note that the primary communication with the server from the client code's perspective is not
             through method calls on this interface, but rather communication through an
             <see cref="T:Microsoft.ML.IPipe`1"/> that the server will listen to throughout its
             lifetime.
             </summary>
        </member>
        <member name="P:Microsoft.ML.ServerChannel.IServer.BaseAddress">
            <summary>
            This should return the base address where the server is. If this server is not actually
            serving content at any URL, this property should be null.
            </summary>
        </member>
        <member name="M:Microsoft.ML.ServerChannel.CreateDefaultServerFactoryOrNull(Microsoft.ML.IHostEnvironment)">
            <summary>
            Creates what might be considered a good "default" server factory, if possible,
            or <c>null</c> if no good default was possible. A <c>null</c> value could be returned,
            for example, if a user opted to remove all implementations of <see cref="T:Microsoft.ML.ServerChannel.IServer"/> and
            the associated <see cref="T:Microsoft.ML.ServerChannel.IServerFactory"/> for security reasons.
            </summary>
        </member>
        <member name="T:Microsoft.ML.ServerChannel.IPendingBundleNotification">
            <summary>
            When a <see cref="T:Microsoft.ML.ServerChannel"/> is created, the creation method will send an implementation
            is a notification sent through an <see cref="T:Microsoft.ML.IPipe`1"/>, to indicate that
            a <see cref="T:Microsoft.ML.ServerChannel.Bundle"/> may be pending soon. Listeners that want to receive the bundle to
            expose it, for example, a web service, should register this interest by passing in an action to be called.
            If no listener registers interest, the server channel that sent the notification will act
            differently by, say, acting as a no-op w.r.t. client calls to it.
            </summary>
        </member>
        <member name="M:Microsoft.ML.ServerChannel.IPendingBundleNotification.Acknowledge(System.Action{Microsoft.ML.ServerChannel.Bundle})">
            <summary>
            Any publisher of the named delegates will call this method, upon receiving an instance
            of this object through the pipe. This method serves two purposes: firstly it detects
            whether anyone is even interested in publishing anything at all, so that we can just
            ignore any input delegates in the case where no one is listening (which, we must expect,
            is the majority of scenarios). The second is that it provides an action to call, once
            all publishing is complete, and <see cref="M:Microsoft.ML.ServerChannel.Publish"/> has been called by the client code.
            </summary>
            <param name="toDo">The callback to perform when all named delegates have been registered,
            and <see cref="M:Microsoft.ML.ServerChannel.Publish"/> is called.</param>
        </member>
        <member name="T:Microsoft.ML.ServerChannel.Bundle">
            <summary>
            The final bundle of published named delegates that a listener can serve.
            </summary>
        </member>
        <member name="F:Microsoft.ML.ServerChannel.Bundle.NameToFuncs">
            <summary>
            This contains a name to delegate mappings. The delegates contained herein are gauranteed to be
            some variety of <see cref="T:System.Func`1"/>, <see cref="T:System.Func`2"/>,
            <see cref="T:System.Func`3"/>, etc.
            </summary>
        </member>
        <member name="F:Microsoft.ML.ServerChannel.Bundle.Identifier">
            <summary>
            This should be a more-or-less unique identifier for the type of API this bundle is producing.
            Its intended use is that it will form part of the URL for the RESTful API, so to the extent that
            it contains multiple tokens they must be slash delimited.
            </summary>
        </member>
        <member name="M:Microsoft.ML.ServerChannelUtilities.StartServerChannel(Microsoft.ML.IChannelProvider,System.String)">
            <summary>
            Convenience method for <see cref="M:Microsoft.ML.ServerChannel.Start(Microsoft.ML.IChannelProvider,System.String)"/> that looks more idiomatic to typical
            channel creation methods on <see cref="T:Microsoft.ML.IChannelProvider"/>.
            </summary>
            <param name="provider">The channel provider.</param>
            <param name="identifier">This is an identifier of the "type" of bundle that is being published,
            and should form a path with forward-slash '/' delimiters.</param>
            <returns>The newly created server channel, or <c>null</c> if there was no listener for
            server channels on <paramref name="provider"/>.</returns>
        </member>
        <member name="T:Microsoft.ML.EntryPoints.SignatureEntryPointModule">
            <summary>
            This is a signature for classes that are 'holders' of entry points and components.
            </summary>
        </member>
        <member name="T:Microsoft.ML.EntryPoints.EntryPointModuleAttribute">
            <summary>
            A simplified assembly attribute for marking EntryPoint modules.
            </summary>
        </member>
        <member name="M:Microsoft.ML.EntryPoints.EntryPointUtils.CheckInputArgs(Microsoft.ML.IExceptionContext,System.Object)">
             <summary>
             Performs checks on an EntryPoint input class equivalent to the checks that are done
             when parsing a JSON EntryPoint graph.
            
             Call this method from EntryPoint methods to ensure that range and required checks are performed
             in a consistent manner when EntryPoints are created directly from code.
             </summary>
        </member>
        <member name="M:Microsoft.ML.EntryPoints.EntryPointUtils.FindColumnOrNull(Microsoft.ML.IExceptionContext,Microsoft.Data.DataView.DataViewSchema,Microsoft.ML.EntryPoints.Optional{System.String})">
            <summary>
            Searches for the given column name in the schema. This method applies a
            common policy that throws an exception if the column is not found
            and the column name was explicitly specified. If the column is not found
            and the column name was not explicitly specified, it returns null.
            </summary>
        </member>
        <member name="M:Microsoft.ML.EntryPoints.EntryPointUtils.AsNullable``1(Microsoft.ML.EntryPoints.Optional{``0})">
            <summary>
            Converts EntryPoint Optional{T} types into nullable types, with the
            implicit value being converted to the null value.
            </summary>
        </member>
        <member name="T:Microsoft.ML.EntryPoints.TlcModule">
            <summary>
            This class defines attributes to annotate module inputs, outputs, entry points etc. when defining
            the module interface.
            </summary>
        </member>
        <member name="T:Microsoft.ML.EntryPoints.TlcModule.ComponentAttribute">
            <summary>
            An attribute used to annotate the component.
            </summary>
        </member>
        <member name="P:Microsoft.ML.EntryPoints.TlcModule.ComponentAttribute.Name">
            <summary>
            The load name of the component. Must be unique within its kind.
            </summary>
        </member>
        <member name="P:Microsoft.ML.EntryPoints.TlcModule.ComponentAttribute.FriendlyName">
            <summary>
            UI friendly name. Can contain spaces and other forbidden for Name symbols.
            </summary>
        </member>
        <member name="P:Microsoft.ML.EntryPoints.TlcModule.ComponentAttribute.Aliases">
            <summary>
            Alternative names of the component. Each alias must also be unique in the component's kind.
            </summary>
        </member>
        <member name="P:Microsoft.ML.EntryPoints.TlcModule.ComponentAttribute.Alias">
            <summary>
            Comma-separated <see cref="P:Microsoft.ML.EntryPoints.TlcModule.ComponentAttribute.Aliases"/>.
            </summary>
        </member>
        <member name="P:Microsoft.ML.EntryPoints.TlcModule.ComponentAttribute.Desc">
            <summary>
            Description of the component.
            </summary>
        </member>
        <member name="P:Microsoft.ML.EntryPoints.TlcModule.ComponentAttribute.DocName">
            <summary>
            This should indicate a name of an embedded resource that contains detailed documents
            for the component, for example, markdown document with the .md extension. The embedded resource
            is assumed to be in the same assembly as the class on which this attribute is ascribed.
            </summary>
        </member>
        <member name="T:Microsoft.ML.EntryPoints.TlcModule.ComponentKindAttribute">
            <summary>
            An attribute used to annotate the signature interface.
            Effectively, this is a way to associate the signature interface with a user-friendly name.
            </summary>
        </member>
        <member name="T:Microsoft.ML.EntryPoints.TlcModule.EntryPointKindAttribute">
            <summary>
            An attribute used to annotate the kind of entry points.
            Typically it is used on the input classes.
            </summary>
        </member>
        <member name="T:Microsoft.ML.EntryPoints.TlcModule.OutputAttribute">
            <summary>
            An attribute used to annotate the outputs of the module.
            </summary>
        </member>
        <member name="P:Microsoft.ML.EntryPoints.TlcModule.OutputAttribute.Name">
            <summary>
            Official name of the output. If it is not specified, the field name is used.
            </summary>
        </member>
        <member name="P:Microsoft.ML.EntryPoints.TlcModule.OutputAttribute.Desc">
            <summary>
            The description of the output.
            </summary>
        </member>
        <member name="P:Microsoft.ML.EntryPoints.TlcModule.OutputAttribute.SortOrder">
            <summary>
            The rank order of the output. Because .NET reflection returns members in an unspecfied order, this
            is the only way to ensure consistency.
            </summary>
        </member>
        <member name="T:Microsoft.ML.EntryPoints.TlcModule.OptionalInputAttribute">
            <summary>
            An attribute to indicate that a field is optional in an EntryPoint module.
            A node can be run without optional input fields.
            </summary>
        </member>
        <member name="T:Microsoft.ML.EntryPoints.TlcModule.RangeAttribute">
            <summary>
            An attribute used to annotate the valid range of a numeric input.
            </summary>
        </member>
        <member name="P:Microsoft.ML.EntryPoints.TlcModule.RangeAttribute.Type">
            <summary>
            The target type of this range attribute, as determined by the type of
            the set range bound values.
            </summary>
        </member>
        <member name="P:Microsoft.ML.EntryPoints.TlcModule.RangeAttribute.Min">
            <summary>
            An inclusive lower bound of the value.
            </summary>
        </member>
        <member name="P:Microsoft.ML.EntryPoints.TlcModule.RangeAttribute.Max">
            <summary>
            An inclusive upper bound of the value.
            </summary>
        </member>
        <member name="P:Microsoft.ML.EntryPoints.TlcModule.RangeAttribute.Inf">
            <summary>
            An exclusive lower bound of the value.
            </summary>
        </member>
        <member name="P:Microsoft.ML.EntryPoints.TlcModule.RangeAttribute.Sup">
            <summary>
            An exclusive upper bound of the value.
            </summary>
        </member>
        <member name="T:Microsoft.ML.EntryPoints.TlcModule.SweepableParamAttribute">
            <summary>
            An attribute used to indicate suggested sweep ranges for parameter sweeping.
            </summary>
        </member>
        <member name="T:Microsoft.ML.EntryPoints.TlcModule.SweepableDiscreteParamAttribute">
            <summary>
            An attribute used to indicate suggested sweep ranges for discrete parameter sweeping.
            The value is the index of the option chosen. Use Options[Value] to get the corresponding
            option using the index.
            </summary>
        </member>
        <member name="T:Microsoft.ML.EntryPoints.TlcModule.SweepableFloatParamAttribute">
            <summary>
            An attribute used to indicate suggested sweep ranges for float parameter sweeping.
            </summary>
        </member>
        <member name="T:Microsoft.ML.EntryPoints.TlcModule.SweepableLongParamAttribute">
            <summary>
            An attribute used to indicate suggested sweep ranges for long parameter sweeping.
            </summary>
        </member>
        <member name="T:Microsoft.ML.EntryPoints.TlcModule.EntryPointAttribute">
            <summary>
            An attribute to mark an entry point of a module.
            </summary>
        </member>
        <member name="P:Microsoft.ML.EntryPoints.TlcModule.EntryPointAttribute.Name">
            <summary>
            The entry point name.
            </summary>
        </member>
        <member name="P:Microsoft.ML.EntryPoints.TlcModule.EntryPointAttribute.Desc">
            <summary>
            The entry point description.
            </summary>
        </member>
        <member name="P:Microsoft.ML.EntryPoints.TlcModule.EntryPointAttribute.UserName">
            <summary>
            UI friendly name. Can contain spaces and other forbidden for Name symbols.
            </summary>
        </member>
        <member name="P:Microsoft.ML.EntryPoints.TlcModule.EntryPointAttribute.ShortName">
            <summary>
            Short name of the Entry Point
            </summary>
        </member>
        <member name="T:Microsoft.ML.EntryPoints.TlcModule.DataKind">
            <summary>
            The list of data types that are supported as inputs or outputs.
            </summary>
        </member>
        <member name="F:Microsoft.ML.EntryPoints.TlcModule.DataKind.Unknown">
            <summary>
            Not used.
            </summary>
        </member>
        <member name="F:Microsoft.ML.EntryPoints.TlcModule.DataKind.Int">
            <summary>
            Integer, including long.
            </summary>
        </member>
        <member name="F:Microsoft.ML.EntryPoints.TlcModule.DataKind.UInt">
            <summary>
            Unsigned integer, including ulong.
            </summary>
        </member>
        <member name="F:Microsoft.ML.EntryPoints.TlcModule.DataKind.Float">
            <summary>
            Floating point, including double.
            </summary>
        </member>
        <member name="F:Microsoft.ML.EntryPoints.TlcModule.DataKind.Char">
            <summary>
            A char.
            </summary>
        </member>
        <member name="F:Microsoft.ML.EntryPoints.TlcModule.DataKind.String">
            <summary>
            A string.
            </summary>
        </member>
        <member name="F:Microsoft.ML.EntryPoints.TlcModule.DataKind.Bool">
            <summary>
            A boolean value.
            </summary>
        </member>
        <member name="F:Microsoft.ML.EntryPoints.TlcModule.DataKind.DataView">
            <summary>
            A dataset, represented by an <see cref="T:Microsoft.Data.DataView.IDataView"/>.
            </summary>
        </member>
        <member name="F:Microsoft.ML.EntryPoints.TlcModule.DataKind.FileHandle">
            <summary>
            A file handle, represented by an <see cref="T:Microsoft.ML.IFileHandle"/>.
            </summary>
        </member>
        <member name="F:Microsoft.ML.EntryPoints.TlcModule.DataKind.TransformModel">
            <summary>
            A transform model, represented by an <see cref="T:Microsoft.ML.EntryPoints.TransformModel"/>.
            </summary>
        </member>
        <member name="F:Microsoft.ML.EntryPoints.TlcModule.DataKind.PredictorModel">
            <summary>
            A predictor model, represented by an <see cref="T:Microsoft.ML.EntryPoints.PredictorModel"/>.
            </summary>
        </member>
        <member name="F:Microsoft.ML.EntryPoints.TlcModule.DataKind.Enum">
            <summary>
            An enum: one value of a specified list.
            </summary>
        </member>
        <member name="F:Microsoft.ML.EntryPoints.TlcModule.DataKind.Array">
            <summary>
            An array (0 or more values of the same type, accessible by index).
            </summary>
        </member>
        <member name="F:Microsoft.ML.EntryPoints.TlcModule.DataKind.Dictionary">
            <summary>
            A dictionary (0 or more values of the same type, identified by a unique string key).
            The underlying C# representation is <see cref="T:System.Collections.Generic.Dictionary`2"/>
            </summary>
        </member>
        <member name="F:Microsoft.ML.EntryPoints.TlcModule.DataKind.Component">
            <summary>
            A component of a specified kind. The component is identified by the "load name" (unique per kind) and,
            optionally, a set of parameters, unique to each component. Example: "BinaryClassifierEvaluator{threshold=0.5}".
            The C# representation is <see cref="T:Microsoft.ML.IComponentFactory"/>.
            </summary>
        </member>
        <member name="T:Microsoft.ML.EntryPoints.Optional">
            <summary>
            The untyped base class for 'maybe'.
            </summary>
        </member>
        <member name="F:Microsoft.ML.EntryPoints.Optional.IsExplicit">
            <summary>
            Whether the value was set 'explicitly', or 'implicitly'.
            </summary>
        </member>
        <member name="T:Microsoft.ML.EntryPoints.Optional`1">
             <summary>
             This is a 'maybe' class that is able to differentiate the cases when the value is set 'explicitly', or 'implicitly'.
             The idea is that if the default value is specified by the user, in some cases it needs to be treated differently
             than if it's auto-filled.
            
             An example is the weight column: the default behavior is to use 'Weight' column if it's present. But if the user explicitly sets
             the weight column to be 'Weight', we need to actually enforce the presence of the column.
             </summary>
             <typeparam name="T">The type of the value</typeparam>
        </member>
        <member name="M:Microsoft.ML.EntryPoints.Optional`1.Implicit(`0)">
            <summary>
            Create the 'implicit' value.
            </summary>
        </member>
        <member name="M:Microsoft.ML.EntryPoints.Optional`1.op_Implicit(Microsoft.ML.EntryPoints.Optional{`0})~`0">
            <summary>
            The implicit conversion into <typeparamref name="T"/>.
            </summary>
        </member>
        <member name="M:Microsoft.ML.EntryPoints.Optional`1.op_Implicit(`0)~Microsoft.ML.EntryPoints.Optional{`0}">
            <summary>
            The implicit conversion from <typeparamref name="T"/>.
            This will assume that the parameter is set 'explicitly'.
            </summary>
        </member>
        <member name="T:Microsoft.ML.EntryPoints.PredictorModel">
            <summary>
            Base type for standard predictor model port type.
            </summary>
        </member>
        <member name="M:Microsoft.ML.EntryPoints.PredictorModel.Save(Microsoft.ML.IHostEnvironment,System.IO.Stream)">
            <summary>
            Save the model to the given stream.
            </summary>
        </member>
        <member name="P:Microsoft.ML.EntryPoints.PredictorModel.TransformModel">
            <summary>
            Extract only the transform portion of the predictor model.
            </summary>
        </member>
        <member name="P:Microsoft.ML.EntryPoints.PredictorModel.Predictor">
            <summary>
            Extract the predictor object out of the predictor model.
            </summary>
        </member>
        <member name="M:Microsoft.ML.EntryPoints.PredictorModel.Apply(Microsoft.ML.IHostEnvironment,Microsoft.ML.EntryPoints.TransformModel)">
            <summary>
            Apply the predictor model to the transform model and return the resulting predictor model.
            </summary>
        </member>
        <member name="M:Microsoft.ML.EntryPoints.PredictorModel.PrepareData(Microsoft.ML.IHostEnvironment,Microsoft.Data.DataView.IDataView,Microsoft.ML.Data.RoleMappedData@,Microsoft.ML.IPredictor@)">
            <summary>
            For a given input data, return role mapped data and the predictor object.
            The scoring entry point will hopefully know how to construct a scorer out of them.
            </summary>
        </member>
        <member name="M:Microsoft.ML.EntryPoints.PredictorModel.GetLabelInfo(Microsoft.ML.IHostEnvironment,Microsoft.Data.DataView.DataViewType@)">
            <summary>
            Returns a string array containing the label names of the label column type predictor was trained on.
            If the training label is a key with text key value annotation, it should return this annotation. The order of the labels should be consistent
            with the key values. Otherwise, it returns null.
            </summary>
            <param name="env"/>
            <param name="labelType">The column type of the label the predictor was trained on.</param>
        </member>
        <member name="M:Microsoft.ML.EntryPoints.PredictorModel.GetTrainingSchema(Microsoft.ML.IHostEnvironment)">
            <summary>
            Returns the <see cref="T:Microsoft.ML.Data.RoleMappedSchema"/> that was used in training.
            </summary>
        </member>
        <member name="T:Microsoft.ML.EntryPoints.TransformModel">
            <summary>
            Interface for standard transform model port type.
            </summary>
        </member>
        <member name="P:Microsoft.ML.EntryPoints.TransformModel.InputSchema">
            <summary>
            The input schema that this transform model was originally instantiated on.
            Note that the schema may have columns that aren't needed by this transform model.
            If an <see cref="T:Microsoft.Data.DataView.IDataView"/> exists with this schema, then applying this transform model to it
            shouldn't fail because of column type issues.
            </summary>
        </member>
        <member name="P:Microsoft.ML.EntryPoints.TransformModel.OutputSchema">
            <summary>
            The output schema that this transform model was originally instantiated on. The schema resulting
            from <see cref="M:Microsoft.ML.EntryPoints.TransformModel.Apply(Microsoft.ML.IHostEnvironment,Microsoft.ML.EntryPoints.TransformModel)"/> may differ from this, similarly to how
            <see cref="P:Microsoft.ML.EntryPoints.TransformModel.InputSchema"/> may differ from the schema of dataviews we apply this transform model to.
            </summary>
        </member>
        <member name="M:Microsoft.ML.EntryPoints.TransformModel.Apply(Microsoft.ML.IHostEnvironment,Microsoft.Data.DataView.IDataView)">
            <summary>
            Apply the transform(s) in the model to the given input data.
            </summary>
        </member>
        <member name="M:Microsoft.ML.EntryPoints.TransformModel.Apply(Microsoft.ML.IHostEnvironment,Microsoft.ML.EntryPoints.TransformModel)">
            <summary>
            Apply the transform(s) in the model to the given transform model.
            </summary>
        </member>
        <member name="M:Microsoft.ML.EntryPoints.TransformModel.Save(Microsoft.ML.IHostEnvironment,System.IO.Stream)">
            <summary>
            Save the model to the given stream.
            </summary>
        </member>
        <member name="M:Microsoft.ML.EntryPoints.TransformModel.AsRowToRowMapper(Microsoft.ML.IExceptionContext)">
            <summary>
            Returns the transform model as an <see cref="T:Microsoft.ML.Data.IRowToRowMapper"/> that can output a row
            given a row with the same schema as <see cref="P:Microsoft.ML.EntryPoints.TransformModel.InputSchema"/>.
            </summary>
            <returns>The transform model as an <see cref="T:Microsoft.ML.Data.IRowToRowMapper"/>. If not all transforms
            in the pipeline are <see cref="T:Microsoft.ML.Data.IRowToRowMapper"/> then it returns <see langword="null"/>.</returns>
        </member>
        <member name="T:Microsoft.ML.TelemetryMessage">
            <summary>
            A telemetry message.
            </summary>
        </member>
        <member name="T:Microsoft.ML.TelemetryTrace">
            <summary>
            Message with one long text and bunch of small properties (limit on value is ~1020 chars)
            </summary>
        </member>
        <member name="T:Microsoft.ML.TelemetryException">
            <summary>
            Message with exception
            </summary>
        </member>
        <member name="T:Microsoft.ML.TelemetryMetric">
            <summary>
            Message with metric value and it properites
            </summary>
        </member>
        <member name="T:Microsoft.ML.PredictionKind">
            <summary>
            Type of prediction task. Note that this is a legacy structure and usage of this should generally be
            discouraged in future projects. Its presence suggests that there are priviledged and supported
            tasks, and anything outside of this is unsupported. This runs rather contrary to the idea of this
            being an expandable framework, and it is inappropriately limiting. For legacy pipelines based on
            <see cref="T:Microsoft.ML.ITrainer"/> and <see cref="T:Microsoft.ML.IPredictor"/> it is still useful, but for things based on
            the <see cref="T:Microsoft.ML.IEstimator`1"/> idiom, it is inappropriate.
            </summary>
        </member>
        <member name="T:Microsoft.ML.IPredictor">
            <summary>
            Weakly typed version of IPredictor.
            </summary>
        </member>
        <member name="P:Microsoft.ML.IPredictor.PredictionKind">
            <summary>
            Return the type of prediction task.
            </summary>
        </member>
        <member name="T:Microsoft.ML.IPredictorProducing`1">
            <summary>
            A predictor the produces values of the indicated type.
            REVIEW: Determine whether this is just a temporary shim or long term solution.
            </summary>
        </member>
        <member name="T:Microsoft.ML.IDistPredictorProducing`2">
            <summary>
            A predictor that produces values and distributions of the indicated types.
            Note that from a public API perspective this is bad.
            </summary>
        </member>
        <member name="T:Microsoft.ML.SignatureTrainer">
            <summary>
            Loadable class signatures for trainers. Typically each trainer should register with
            both SignatureTrainer and SignatureXxxTrainer where Xxx is the prediction kind.
            </summary>
        </member>
        <member name="T:Microsoft.ML.ITrainer">
            <summary>
            The base interface for a trainers. Implementors should not implement this interface directly,
            but rather implement the more specific <see cref="T:Microsoft.ML.ITrainer`1"/>.
            </summary>
        </member>
        <member name="P:Microsoft.ML.ITrainer.Info">
            <summary>
            Auxiliary information about the trainer in terms of its capabilities
            and requirements.
            </summary>
        </member>
        <member name="P:Microsoft.ML.ITrainer.PredictionKind">
            <summary>
            Return the type of prediction task for the produced predictor.
            </summary>
        </member>
        <member name="M:Microsoft.ML.ITrainer.Train(Microsoft.ML.TrainContext)">
            <summary>
             Trains a predictor.
            </summary>
            <param name="context">A context containing at least the training data</param>
            <returns>The trained predictor</returns>
            <seealso cref="M:Microsoft.ML.ITrainer`1.Train(Microsoft.ML.TrainContext)"/>
        </member>
        <member name="T:Microsoft.ML.ITrainer`1">
            <summary>
            Strongly typed generic interface for a trainer. A trainer object takes training data
            and produces a predictor.
            </summary>
            <typeparam name="TPredictor"> Type of predictor produced</typeparam>
        </member>
        <member name="M:Microsoft.ML.ITrainer`1.Train(Microsoft.ML.TrainContext)">
            <summary>
             Trains a predictor.
            </summary>
            <param name="context">A context containing at least the training data</param>
            <returns>The trained predictor</returns>
        </member>
        <member name="M:Microsoft.ML.TrainerExtensions.Train(Microsoft.ML.ITrainer,Microsoft.ML.Data.RoleMappedData)">
            <summary>
            Convenience train extension for the case where one has only a training set with no auxiliary information.
            Equivalent to calling <see cref="M:Microsoft.ML.ITrainer.Train(Microsoft.ML.TrainContext)"/>
            on a <see cref="T:Microsoft.ML.TrainContext"/> constructed with <paramref name="trainData"/>.
            </summary>
            <param name="trainer">The trainer</param>
            <param name="trainData">The training data.</param>
            <returns>The trained predictor</returns>
        </member>
        <member name="M:Microsoft.ML.TrainerExtensions.Train``1(Microsoft.ML.ITrainer{``0},Microsoft.ML.Data.RoleMappedData)">
            <summary>
            Convenience train extension for the case where one has only a training set with no auxiliary information.
            Equivalent to calling <see cref="M:Microsoft.ML.ITrainer`1.Train(Microsoft.ML.TrainContext)"/>
            on a <see cref="T:Microsoft.ML.TrainContext"/> constructed with <paramref name="trainData"/>.
            </summary>
            <param name="trainer">The trainer</param>
            <param name="trainData">The training data.</param>
            <returns>The trained predictor</returns>
        </member>
        <member name="T:Microsoft.ML.TreePredictor.ITreeEnsemble">
            <summary>
            Predictor that has ensemble tree structures and returns collection of trees.
            </summary>
        </member>
        <member name="P:Microsoft.ML.TreePredictor.ITreeEnsemble.NumTrees">
            <summary>
            Returns the number of trees in the ensemble.
            </summary>
        </member>
        <member name="M:Microsoft.ML.TreePredictor.ITreeEnsemble.GetTrees">
            <summary>
            Returns the collection of trees.
            </summary>
            <returns>Collection of trees</returns>
        </member>
        <member name="T:Microsoft.ML.TreePredictor.ITree">
            <summary>
            Type of tree used in ensemble of tree based predictors
            </summary>
        </member>
        <member name="P:Microsoft.ML.TreePredictor.ITree.GtChild">
            <summary>
            Returns the array of right(Greater than) child nodes of every interior nodes
            </summary>
        </member>
        <member name="P:Microsoft.ML.TreePredictor.ITree.LteChild">
            <summary>
            Returns the array of left(Leser than or equal to) nodes of every interior nodes
            </summary>
        </member>
        <member name="P:Microsoft.ML.TreePredictor.ITree.NumNodes">
            <summary>
            returns the number of interior nodes.
            </summary>
        </member>
        <member name="P:Microsoft.ML.TreePredictor.ITree.NumLeaves">
            <summary>
            Returns the number of leaf nodes.
            </summary>
        </member>
        <member name="M:Microsoft.ML.TreePredictor.ITree.GetNode(System.Int32,System.Boolean,System.Collections.Generic.IEnumerable{System.String})">
            <summary>
            Returns node structure for the given node
            </summary>
            <param name="nodeId">Node id</param>
            <param name="isLeaf">Flag to denote whether the node is leaf or not</param>
            <param name="featureNames">Feature names collection</param>
            <returns>Node structure</returns>
        </member>
        <member name="T:Microsoft.ML.TreePredictor.ITree`1">
            <summary>
            Type of tree used in ensemble of tree based predictors
            </summary>
            <typeparam name="TFeatures">Type of features container (instance) on which to make predictions</typeparam>
        </member>
        <member name="M:Microsoft.ML.TreePredictor.ITree`1.GetLeaf(`0@)">
            <summary>
            Returns the leaf node for the given instance.
            </summary>
            <param name="features">Type of features container (instance) on which to make predictions</param>
            <returns>node id</returns>
            <typeparamref name="TFeatures">Type of features container (instance) on which to make predictions</typeparamref>
        </member>
        <member name="T:Microsoft.ML.TreePredictor.INode">
            <summary>
            Type to represent the structure of node
            </summary>
        </member>
        <member name="P:Microsoft.ML.TreePredictor.INode.KeyValues">
            <summary>
            Returns Key value pairs representing the properties of the node.
            </summary>
        </member>
        <member name="T:Microsoft.ML.TreePredictor.NodeKeys">
            <summary>
            Keys to represent the properties of node.
            </summary>
        </member>
        <member name="F:Microsoft.ML.TreePredictor.NodeKeys.SplitName">
            <summary>
            Name of the the interior node. It is Feature name if it is fasttree. Type is string for default trees.
            </summary>
        </member>
        <member name="F:Microsoft.ML.TreePredictor.NodeKeys.SplitGain">
            <summary>
            Split gain of the interior node. Type is double for default trees.
            </summary>
        </member>
        <member name="F:Microsoft.ML.TreePredictor.NodeKeys.Threshold">
            <summary>
            Threshold value of the interior node. Type is string for default trees.
            It is expected that the string has exactly two space separated components.
            i. The first one should be the operator
            ii. The second one should be the actual threshold
            For ex., for a split like f1 &lt;= 10, expected Threshold is "&lt;= 10"
            For a split like color not-in { blue, green }, expected Threshold is "not-in { blue, green }"
            </summary>
        </member>
        <member name="F:Microsoft.ML.TreePredictor.NodeKeys.GainValue">
            <summary>
            Gain value (specific to fasttree) of the interior node. Type is double for default trees.
            </summary>
        </member>
        <member name="F:Microsoft.ML.TreePredictor.NodeKeys.PreviousLeafValue">
            <summary>
            Previous leaf value(specific to fasttree) of the interior node. Type is double for default trees.
            </summary>
        </member>
        <member name="F:Microsoft.ML.TreePredictor.NodeKeys.LeafValue">
            <summary>
            Leaf value of the leaf node. Type is double for default trees.
            </summary>
        </member>
        <member name="F:Microsoft.ML.TreePredictor.NodeKeys.Extras">
            <summary>
            Extra items that will be displayed in the tool-tip. Type is string for default trees.
            </summary>
        </member>
        <member name="T:Microsoft.ML.TrainContext">
            <summary>
            Holds information relevant to trainers. Instances of this class are meant to be constructed and passed
            into <see cref="M:Microsoft.ML.ITrainer`1.Train(Microsoft.ML.TrainContext)"/> or <see cref="M:Microsoft.ML.ITrainer.Train(Microsoft.ML.TrainContext)"/>.
            This holds at least a training set, as well as optionally a predictor.
            </summary>
        </member>
        <member name="P:Microsoft.ML.TrainContext.TrainingSet">
            <summary>
            The training set. Cannot be <c>null</c>.
            </summary>
        </member>
        <member name="P:Microsoft.ML.TrainContext.ValidationSet">
            <summary>
            The validation set. Can be <c>null</c>. Note that passing a non-<c>null</c> validation set into
            a trainer that does not support validation sets should not be considered an error condition. It
            should simply be ignored in that case.
            </summary>
        </member>
        <member name="P:Microsoft.ML.TrainContext.TestSet">
            <summary>
            The test set, whose uses are very similar to validation set but it should not directly and indirectly
            affect the training process. One major difference between validation set and test test is that validation
            can affect the training process by, for example, early stopping. Note that early stopping is a technique
            which terminates the training process once the scores computed on validation set starts getting worse.
            </summary>
        </member>
        <member name="P:Microsoft.ML.TrainContext.InitialPredictor">
            <summary>
            The initial predictor, for incremental training. Note that if a <see cref="T:Microsoft.ML.ITrainer"/> implementor
            does not support incremental training, then it can ignore it similarly to how one would ignore
            <see cref="P:Microsoft.ML.TrainContext.ValidationSet"/>. However, if the trainer does support incremental training and there
            is something wrong with a non-<c>null</c> value of this, then the trainer ought to throw an exception.
            </summary>
        </member>
        <member name="M:Microsoft.ML.TrainContext.#ctor(Microsoft.ML.Data.RoleMappedData,Microsoft.ML.Data.RoleMappedData,Microsoft.ML.Data.RoleMappedData,Microsoft.ML.IPredictor)">
            <summary>
            Constructor, given a training set and optional other arguments.
            </summary>
            <param name="trainingSet">Will set <see cref="P:Microsoft.ML.TrainContext.TrainingSet"/> to this value. This must be specified</param>
            <param name="validationSet">Will set <see cref="P:Microsoft.ML.TrainContext.ValidationSet"/> to this value if specified</param>
            <param name="testSet">Will set <see cref="P:Microsoft.ML.TrainContext.TestSet"/> to this value if specified</param>
            <param name="initialPredictor">Will set <see cref="P:Microsoft.ML.TrainContext.InitialPredictor"/> to this value if specified</param>
        </member>
        <member name="T:Microsoft.ML.TrainerInfo">
            <summary>
            Instances of this class posses information about trainers, in terms of their requirements and capabilities.
            </summary>
        </member>
        <member name="P:Microsoft.ML.TrainerInfo.NeedNormalization">
            <summary>
            Whether the trainer needs to see data in normalized form. Only non-parametric trainers will tend to return
            <see langword="false"/> here.
            </summary>
        </member>
        <member name="P:Microsoft.ML.TrainerInfo.NeedCalibration">
            <summary>
            Whether the trainer needs calibration to produce probabilities. As a general rule only trainers that produce
            binary classifier predictors that also do not have a natural probabilistic interpretation should have a
            <see langword="true"/> value here.
            </summary>
        </member>
        <member name="P:Microsoft.ML.TrainerInfo.WantCaching">
            <summary>
            Whether this trainer could benefit from a cached view of the data. Trainers that have few passes over the
            data, or that need to build their own custom data structure over the data, will have a <c>false</c> here.
            </summary>
        </member>
        <member name="P:Microsoft.ML.TrainerInfo.SupportsValidation">
            <summary>
            Whether the trainer supports validation set via <see cref="P:Microsoft.ML.TrainContext.ValidationSet"/>. Not implementing
            this interface and returning <c>false</c> from this property is an indication the trainer does not support
            that.
            </summary>
        </member>
        <member name="P:Microsoft.ML.TrainerInfo.SupportsTest">
            <summary>
            Whether the trainer can use test set via <see cref="P:Microsoft.ML.TrainContext.TestSet"/>. Not implementing
            this interface and returning <c>false</c> from this property is an indication the trainer does not support
            that.
            </summary>
        </member>
        <member name="P:Microsoft.ML.TrainerInfo.SupportsIncrementalTraining">
            <summary>
            Whether the trainer can support incremental trainers via <see cref="P:Microsoft.ML.TrainContext.InitialPredictor"/>. Not
            implementing this interface and returning <c>true</c> from this property is an indication the trainer does
            not support that.
            </summary>
        </member>
        <member name="M:Microsoft.ML.TrainerInfo.#ctor(System.Boolean,System.Boolean,System.Boolean,System.Boolean,System.Boolean,System.Boolean)">
            <summary>
            Initializes with the given parameters. The parameters have default values for the most typical values
            for most classical trainers.
            </summary>
            <param name="normalization">The value for the property <see cref="P:Microsoft.ML.TrainerInfo.NeedNormalization"/></param>
            <param name="calibration">The value for the property <see cref="P:Microsoft.ML.TrainerInfo.NeedCalibration"/></param>
            <param name="caching">The value for the property <see cref="P:Microsoft.ML.TrainerInfo.WantCaching"/></param>
            <param name="supportValid">The value for the property <see cref="P:Microsoft.ML.TrainerInfo.SupportsValidation"/></param>
            <param name="supportIncrementalTrain">The value for the property <see cref="P:Microsoft.ML.TrainerInfo.SupportsIncrementalTraining"/></param>
            <param name="supportTest">The value for the property <see cref="P:Microsoft.ML.TrainerInfo.SupportsTest"/></param>
        </member>
        <member name="T:Microsoft.ML.Internal.Utilities.BigArray`1">
            <summary>
            An array-like data structure that supports storing more than
            <see cref="F:Microsoft.ML.Internal.Utilities.Utils.ArrayMaxSize"/> many entries, up to 0x7FEFFFFF00000L.
            The entries are indexed by 64-bit integers, and a single entry can be accessed by
            the indexer if no modifications to the entries is desired, or the <see cref="M:Microsoft.ML.Internal.Utilities.BigArray`1.ApplyAt(System.Int64,Microsoft.ML.Internal.Utilities.BigArray{`0}.Visitor)"/>
            method. Efficient looping can be accomplished by calling the <see cref="M:Microsoft.ML.Internal.Utilities.BigArray`1.ApplyRange(System.Int64,System.Int64,Microsoft.ML.Internal.Utilities.BigArray{`0}.Visitor)"/> method.
            This data structure employs the "length and capacity" pattern. The logical length
            can be retrieved from the <see cref="P:Microsoft.ML.Internal.Utilities.BigArray`1.Length"/> property, which can possibly be strictly less
            than the total capacity.
            </summary>
            <typeparam name="T">The type of entries.</typeparam>
        </member>
        <member name="P:Microsoft.ML.Internal.Utilities.BigArray`1.Length">
            <summary>
            Gets the logical length of the big array.
            </summary>
        </member>
        <member name="P:Microsoft.ML.Internal.Utilities.BigArray`1.Item(System.Int64)">
            <summary>
            Gets or sets the entry at <paramref name="index"/>.
            </summary>
            <remarks>
            This indexer is not efficient for looping. If looping access to entries is desired,
            use the <see cref="M:Microsoft.ML.Internal.Utilities.BigArray`1.ApplyRange(System.Int64,System.Int64,Microsoft.ML.Internal.Utilities.BigArray{`0}.Visitor)"/> method instead.
            Note that unlike a normal array, the value returned from this indexer getter cannot be modified
            (for example, by ++ operator or passing into a method as a ref parameter). To modify an entry, use
            the <see cref="M:Microsoft.ML.Internal.Utilities.BigArray`1.ApplyAt(System.Int64,Microsoft.ML.Internal.Utilities.BigArray{`0}.Visitor)"/> method instead.
            </remarks>
        </member>
        <member name="M:Microsoft.ML.Internal.Utilities.BigArray`1.#ctor(System.Int64)">
            <summary>
            Initializes a new instance of the <see cref="T:Microsoft.ML.Internal.Utilities.BigArray`1"/> class with a specified size.
            </summary>
        </member>
        <member name="M:Microsoft.ML.Internal.Utilities.BigArray`1.ApplyAt(System.Int64,Microsoft.ML.Internal.Utilities.BigArray{`0}.Visitor)">
            <summary>
            Applies a <see cref="T:Microsoft.ML.Internal.Utilities.BigArray`1.Visitor"/> method at a given <paramref name="index"/>.
            </summary>
        </member>
        <member name="M:Microsoft.ML.Internal.Utilities.BigArray`1.ApplyRange(System.Int64,System.Int64,Microsoft.ML.Internal.Utilities.BigArray{`0}.Visitor)">
            <summary>
            Implements a more efficient way to loop over index range in [min, lim) and apply
            the specified method delegate.
            </summary>
        </member>
        <member name="M:Microsoft.ML.Internal.Utilities.BigArray`1.FillRange(System.Int64,System.Int64,`0)">
            <summary>
            Fills the entries with index in [min, lim) with the given value.
            </summary>
        </member>
        <member name="M:Microsoft.ML.Internal.Utilities.BigArray`1.Resize(System.Int64)">
            <summary>
            Resizes the array so that its logical length equals <paramref name="newLength"/>. This method
            is more efficient than initialize another array and copy the entries because it preserves
            existing blocks. The actual capacity of the array may become larger than <paramref name="newLength"/>.
            If <paramref name="newLength"/> equals <see cref="P:Microsoft.ML.Internal.Utilities.BigArray`1.Length"/>, then no operation is done.
            If <paramref name="newLength"/> is less than <see cref="P:Microsoft.ML.Internal.Utilities.BigArray`1.Length"/>, the array shrinks in size
            so that both its length and its capacity equal <paramref name="newLength"/>.
            If <paramref name="newLength"/> is larger than <see cref="P:Microsoft.ML.Internal.Utilities.BigArray`1.Length"/>, the array capacity grows
            to the smallest integral multiple of <see cref="F:Microsoft.ML.Internal.Utilities.BigArray`1.BlockSize"/> that is larger than <paramref name="newLength"/>,
            unless <paramref name="newLength"/> is less than <see cref="F:Microsoft.ML.Internal.Utilities.BigArray`1.BlockSize"/>, in which case the capacity
            grows to double its current capacity or <paramref name="newLength"/>, which ever is larger,
            but up to <see cref="F:Microsoft.ML.Internal.Utilities.BigArray`1.BlockSize"/>.
            </summary>
        </member>
        <member name="M:Microsoft.ML.Internal.Utilities.BigArray`1.TrimCapacity">
            <summary>
            Trims the capacity to logical length.
            </summary>
        </member>
        <member name="M:Microsoft.ML.Internal.Utilities.BigArray`1.AddRange(System.ReadOnlySpan{`0})">
            <summary>
            Appends the elements of <paramref name="src"/> to the end.
            This method is thread safe related to calls to <see cref="M:CopyTo"/> (assuming those copy operations
            are happening over ranges already added), but concurrent calls to
            <see cref="M:AddRange"/> should not be attempted. Intended usage is that
            one thread will call this method, while multiple threads may access
            previously added ranges from <see cref="M:CopyTo"/>, concurrently with
            this method or themselves.
            </summary>
        </member>
        <member name="M:Microsoft.ML.Internal.Utilities.BigArray`1.CopyTo(System.Int64,System.Span{`0},System.Int32)">
            <summary>
            Copies the subarray starting from index <paramref name="idx"/> of length
            <paramref name="length"/> to the destination array <paramref name="dst"/>.
            Concurrent calls to this method is valid even with one single concurrent call
            to <see cref="M:AddRange"/>.
            </summary>
        </member>
        <member name="M:Microsoft.ML.Internal.Utilities.BinFinderBase.GetSplitValue(System.Single,System.Single)">
            <summary>
            This should normally be just (a + b) / 2, except in one interesting case:
            If a and b are 'consecutive' floats (they differ only in the least significant bit),
            the above expression is possible to be rounded to a.
            This can lead to bin bounds that are not strictly increasing!
            Also note that the simple (a + b) / 2 can overflow, that's the reason for a / 2 + b / 2.
            </summary>
        </member>
        <member name="M:Microsoft.ML.Internal.Utilities.BinFinderBase.GetSplitValue(System.Double,System.Double)">
            <summary>
            This should normally be just (a + b) / 2, except in one interesting case:
            If a and b are 'consecutive' floats (they differ only in the least significant bit),
            the above expression is possible to be rounded to a.
            This can lead to bin bounds that are not strictly increasing!
            Also note that the simple (a + b) / 2 can overflow, that's the reason for a / 2 + b / 2.
            </summary>
        </member>
        <member name="M:Microsoft.ML.Internal.Utilities.GreedyBinFinder.PlacePegs">
            <summary>
            Initial placement of the pegs.
            Places pegs one by one and always picks the largest existing segment to split.
            </summary>
        </member>
        <member name="M:Microsoft.ML.Internal.Utilities.GreedyBinFinder.GetSegmentSplit(System.Int32,System.Int32)">
            <summary>
            Gets the best split for a peg between min and max.
            In case of a tie, use 'pos' to pick the location closer to the more natural split.
            </summary>
        </member>
        <member name="M:Microsoft.ML.Internal.Utilities.GreedyBinFinder.GetSplitEnergy(System.Int32,System.Int32,System.Int32)">
            <summary>
            Computes the energy reduction for splitting segment [min, max] at 'split' point
            </summary>
        </member>
        <member name="M:Microsoft.ML.Internal.Utilities.GreedyBinFinder.BetterPlacement(System.Int32,System.Int32,System.Int32)">
            <summary>
            Returns true if 'i' is a better peg placement than 'j', which means it is closer to the ideal position for peg 'pos'
            </summary>
        </member>
        <member name="M:Microsoft.ML.Internal.Utilities.GreedyBinFinder.ReduceEnergy">
            <summary>
            After the initial peg placement,
            </summary>
        </member>
        <member name="M:Microsoft.ML.Internal.Utilities.DynamicBinFinder.GetEnergyBounds(System.Int32,System.Int32,System.Double,System.Double@,System.Double@)">
            <summary>
            For the remaining bins, compute the best energy distribution and the worst energy distribution
            The best energy distribution:
                - make the distances as equal as possible;
                - some of them will be 'ave' and the rest will be 'ave+1'
            The worst energy distribution:
                - all except one distance will be 1
            </summary>
        </member>
        <member name="F:Microsoft.ML.Internal.Utilities.Utils.CustomSearchDirEnvVariable">
            <summary>
            Environment variable containing optional resources path.
            </summary>
        </member>
        <member name="M:Microsoft.ML.Internal.Utilities.Utils.FindExistentFileOrNull(System.String,System.String,System.String,System.Type)">
             <summary>
             Attempts to find a file that is expected to be distributed with a TLC component. Searches
             in the following order:
             1. In the customSearchDir directory, if it is provided.
             2. In the custom search directory specified by the
                <seealso cref="F:Microsoft.ML.Internal.Utilities.Utils.CustomSearchDirEnvVariable"/> environment variable.
             3. In the root folder of the provided assembly.
             4. In the folder of this assembly.
             In each case it searches the file in the directory provided and combined with folderPrefix.
            
             If any of these locations contain the file, a full local path will be returned, otherwise this
             method will return null.
             </summary>
             <param name="fileName">File name to find</param>
             <param name="folderPrefix">folder prefix, relative to the current or customSearchDir</param>
             <param name="customSearchDir">
             Custom directory to search for resources.
             If null, the path specified in the environment variable <seealso cref="F:Microsoft.ML.Internal.Utilities.Utils.CustomSearchDirEnvVariable"/>
             will be used.
             </param>
             <param name="assemblyForBasePath">
             Assembly type to search the path of.
             </param>
             <returns>
             Path to the existing file. Null if not found.
             </returns>
        </member>
        <member name="M:Microsoft.ML.Internal.Utilities.Utils.CreateFolderIfNotExists(System.String)">
            <summary>
             Given a folder path, create it if it doesn't exist.
             Fails if the folder name is empty, or can't create the folder.
            </summary>
        </member>
        <member name="M:Microsoft.ML.Internal.Utilities.Utils.CopyRange(System.IO.Stream,System.IO.Stream,System.Int64,System.Int32)">
            <summary>
            Similar to Stream.CopyTo but takes a length rather than assuming copy to end.  Returns amount copied.
            </summary>
            <param name="source">Source stream to copy from</param>
            <param name="destination">Destination stream to copy to</param>
            <param name="length">Number of bytes to copy</param>
            <param name="bufferSize">Size of buffer to use when copying, default is 81920 to match that of Stream</param>
            <returns>number of bytes copied</returns>
        </member>
        <member name="M:Microsoft.ML.Internal.Utilities.Utils.WriteIntArray(System.IO.BinaryWriter,System.ReadOnlySpan{System.Int32})">
            <summary>
            Writes a length prefixed span of ints.
            </summary>
        </member>
        <member name="M:Microsoft.ML.Internal.Utilities.Utils.WriteIntsNoCount(System.IO.BinaryWriter,System.ReadOnlySpan{System.Int32})">
            <summary>
            Writes a span of ints without the length prefix.
            </summary>
        </member>
        <member name="M:Microsoft.ML.Internal.Utilities.Utils.WriteUIntArray(System.IO.BinaryWriter,System.ReadOnlySpan{System.UInt32})">
            <summary>
            Writes a length prefixed span of uints.
            </summary>
        </member>
        <member name="M:Microsoft.ML.Internal.Utilities.Utils.WriteUIntsNoCount(System.IO.BinaryWriter,System.ReadOnlySpan{System.UInt32})">
            <summary>
            Writes a span of uints without the length prefix.
            </summary>
        </member>
        <member name="M:Microsoft.ML.Internal.Utilities.Utils.WriteByteArray(System.IO.BinaryWriter,System.Byte[])">
            <summary>
            Writes a length prefixed array of bytes.
            </summary>
        </member>
        <member name="M:Microsoft.ML.Internal.Utilities.Utils.WriteByteArray(System.IO.BinaryWriter,System.ReadOnlySpan{System.Byte})">
            <summary>
            Writes a length prefixed span of bytes.
            </summary>
        </member>
        <member name="M:Microsoft.ML.Internal.Utilities.Utils.WriteByteArray(System.IO.BinaryWriter,System.Byte[],System.Int32)">
            <summary>
            Writes a length prefixed array of bytes.
            </summary>
        </member>
        <member name="M:Microsoft.ML.Internal.Utilities.Utils.WriteBytesNoCount(System.IO.BinaryWriter,System.Byte[],System.Int32)">
            <summary>
            Writes an array of bytes without the length prefix.
            </summary>
        </member>
        <member name="M:Microsoft.ML.Internal.Utilities.Utils.WriteSingleArray(System.IO.BinaryWriter,System.ReadOnlySpan{System.Single})">
            <summary>
            Writes a length prefixed span of Floats.
            </summary>
        </member>
        <member name="M:Microsoft.ML.Internal.Utilities.Utils.WriteSingleArray(System.IO.BinaryWriter,System.Collections.Generic.IEnumerable{System.Single},System.Int32)">
            <summary>
            Writes a length prefixed array of Floats.
            </summary>
        </member>
        <member name="M:Microsoft.ML.Internal.Utilities.Utils.WriteSinglesNoCount(System.IO.BinaryWriter,System.ReadOnlySpan{System.Single})">
            <summary>
            Writes a span of Floats without the length prefix.
            </summary>
        </member>
        <member name="M:Microsoft.ML.Internal.Utilities.Utils.WriteDoubleArray(System.IO.BinaryWriter,System.ReadOnlySpan{System.Double})">
            <summary>
            Writes a length prefixed span of doubles.
            </summary>
        </member>
        <member name="M:Microsoft.ML.Internal.Utilities.Utils.WriteDoublesNoCount(System.IO.BinaryWriter,System.ReadOnlySpan{System.Double})">
            <summary>
            Writes a span of doubles without the length prefix.
            </summary>
        </member>
        <member name="M:Microsoft.ML.Internal.Utilities.Utils.WriteBoolByteArray(System.IO.BinaryWriter,System.ReadOnlySpan{System.Boolean})">
            <summary>
            Writes a length prefixed span of bools as bytes with 0/1 values.
            </summary>
        </member>
        <member name="M:Microsoft.ML.Internal.Utilities.Utils.WriteBoolBytesNoCount(System.IO.BinaryWriter,System.ReadOnlySpan{System.Boolean})">
            <summary>
            Writes a span of bools as bytes with 0/1 values, without the length prefix.
            </summary>
        </member>
        <member name="M:Microsoft.ML.Internal.Utilities.Utils.WriteCharArray(System.IO.BinaryWriter,System.ReadOnlySpan{System.Char})">
            <summary>
            Writes a length prefixed span of chars.
            </summary>
        </member>
        <member name="M:Microsoft.ML.Internal.Utilities.Utils.WriteBitArray(System.IO.BinaryWriter,System.Collections.BitArray)">
            <summary>
            Writes a length prefixed array of packed bits.
            </summary>
        </member>
        <member name="M:Microsoft.ML.Internal.Utilities.Utils.WriteLeb128Int(System.IO.BinaryWriter,System.UInt64)">
            <summary>
            Writes what Microsoft calls a UTF-7 encoded number in the binary reader and
            writer string methods. For non-negative integers this is equivalent to LEB128
            (see https://en.wikipedia.org/wiki/LEB128).
            </summary>
        </member>
        <member name="M:Microsoft.ML.Internal.Utilities.Utils.Leb128IntLength(System.UInt64)">
            <summary>
            The number of bytes that would be written if one were to attempt to write
            the value in LEB128.
            </summary>
        </member>
        <member name="M:Microsoft.ML.Internal.Utilities.Utils.ReadBlock(System.IO.Stream,System.Byte[],System.Int32,System.Int32)">
            <summary>
            If this return it will read exactly length bytes, and unlike the
            regular read method fails if it cannot.
            </summary>
            <param name="s">The stream</param>
            <param name="buff">The buffer into which to write the data.</param>
            <param name="offset">The offset of the output array into which to write.</param>
            <param name="length">The number of bytes to read.</param>
        </member>
        <member name="M:Microsoft.ML.Internal.Utilities.Utils.ReadLeb128Int(System.IO.BinaryReader)">
            <summary>
            Reads a LEB128 encoded unsigned integer.
            </summary>
        </member>
        <member name="M:Microsoft.ML.Internal.Utilities.Utils.OpenWriter(System.IO.Stream,System.Text.Encoding,System.Int32,System.Boolean)">
            <summary>
            A convenience method to open a stream writer, by default with no-BOM UTF-8 encoding,
            buffer size of 1K, and the stream left open.
            </summary>
        </member>
        <member name="M:Microsoft.ML.Internal.Utilities.Utils.CheckOptionalUserDirectory(System.String,System.String)">
            <summary>
            Checks that the directory of the file name passed in already exists.
            This is meant to be called before calling an API that creates the file,
            so the file need not exist.
            </summary>
            <param name="file">An absolute or relative file path, or null to skip the check
            (useful for optional user parameters)</param>
            <param name="userArgument">The user level parameter name, as exposed by the command line help</param>
        </member>
        <member name="T:Microsoft.ML.Internal.Utilities.Utils.ImmediateBackgroundThreadPool">
            <summary>
            Naive thread pool focused on reducing the latency to execution of chunky work items as much as possible.
            If a thread is ready to process a work item the moment a work item is queued, it's used, otherwise
            a new thread is created. This is meant as a stop-gap measure for workloads that would otherwise be
            creating a new thread for every work item.
            </summary>
        </member>
        <member name="F:Microsoft.ML.Internal.Utilities.Utils.ImmediateBackgroundThreadPool.IdleMilliseconds">
            <summary>How long should threads wait around for additional work items before retiring themselves.</summary>
        </member>
        <member name="F:Microsoft.ML.Internal.Utilities.Utils.ImmediateBackgroundThreadPool._queue">
            <summary>The queue of work items. Also used as a lock to protect all relevant state.</summary>
        </member>
        <member name="F:Microsoft.ML.Internal.Utilities.Utils.ImmediateBackgroundThreadPool._availableThreads">
            <summary>The number of threads currently waiting for work to arrive.</summary>
        </member>
        <member name="M:Microsoft.ML.Internal.Utilities.Utils.ImmediateBackgroundThreadPool.Queue(System.Action)">
            <summary>
            Queues an <see cref="T:System.Action"/> delegate to be executed immediately on another thread,
            and returns a <see cref="T:System.Threading.Tasks.Task"/> that represents its eventual completion. The task will
            always end in the <see cref="F:System.Threading.Tasks.TaskStatus.RanToCompletion"/> state; if the delegate throws
            an exception, it'll be allowed to propagate on the thread, crashing the process.
            </summary>
        </member>
        <member name="M:Microsoft.ML.Internal.Utilities.Utils.ImmediateBackgroundThreadPool.Queue(System.Action{System.Object},System.Object)">
            <summary>
            Queues an <see cref="T:System.Action`1"/> delegate and associated state to be executed immediately on another thread,
            and returns a <see cref="T:System.Threading.Tasks.Task"/> that represents its eventual completion. The task will
            always end in the <see cref="F:System.Threading.Tasks.TaskStatus.RanToCompletion"/> state; if the delegate throws
            an exception, it'll be allowed to propagate on the thread, crashing the process.
            </summary>
        </member>
        <member name="M:Microsoft.ML.Internal.Utilities.Utils.CopyTo``1(System.Collections.Generic.List{``0},System.Span{``0},System.Nullable{System.Int32})">
            <summary>
            Copies the values from src to dst.
            </summary>
            <remarks>
            This can be removed once we have the APIs from https://github.com/dotnet/corefx/issues/33006.
            </remarks>
        </member>
        <member name="M:Microsoft.ML.Internal.Utilities.Utils.FindIndexSorted(System.Collections.Generic.IList{System.Int32},System.Int32)">
            <summary>
            Assumes input is sorted and finds value using BinarySearch.
            If value is not found, returns the logical index of 'value' in the sorted list i.e index of the first element greater than value.
            In case of duplicates it returns the index of the first one.
            It guarantees that items before the returned index are &lt; value, while those at and after the returned index are &gt;= value.
            </summary>
        </member>
        <member name="M:Microsoft.ML.Internal.Utilities.Utils.FindIndexSorted(System.Collections.Generic.IList{System.Single},System.Single)">
            <summary>
            Assumes input is sorted and finds value using BinarySearch.
            If value is not found, returns the logical index of 'value' in the sorted list i.e index of the first element greater than value.
            In case of duplicates it returns the index of the first one.
            It guarantees that items before the returned index are &lt; value, while those at and after the returned index are &gt;= value.
            </summary>
        </member>
        <member name="M:Microsoft.ML.Internal.Utilities.Utils.FindIndexSorted(System.Double[],System.Double)">
            <summary>
            Assumes input is sorted and finds value using BinarySearch.
            If value is not found, returns the logical index of 'value' in the sorted list i.e index of the first element greater than value.
            In case of duplicates it returns the index of the first one.
            It guarantees that items before the returned index are &lt; value, while those at and after the returned index are &gt;= value.
            </summary>
        </member>
        <member name="M:Microsoft.ML.Internal.Utilities.Utils.TryFindIndexSorted(System.Int32[],System.Int32,System.Int32,System.Int32,System.Int32@)">
            <summary>
            Akin to <c>FindIndexSorted</c>, except stores the found index in the output
            <c>index</c> parameter, and returns whether that index is a valid index
            pointing to a value equal to the input parameter <c>value</c>.
            </summary>
        </member>
        <member name="M:Microsoft.ML.Internal.Utilities.Utils.TryFindIndexSorted(System.ReadOnlySpan{System.Int32},System.Int32,System.Int32,System.Int32,System.Int32@)">
            <summary>
            Akin to <c>FindIndexSorted</c>, except stores the found index in the output
            <c>index</c> parameter, and returns whether that index is a valid index
            pointing to a value equal to the input parameter <c>value</c>.
            </summary>
        </member>
        <member name="M:Microsoft.ML.Internal.Utilities.Utils.FindIndexSorted(System.Int32[],System.Int32,System.Int32,System.Int32)">
            <summary>
            Assumes input is sorted and finds value using BinarySearch.
            If value is not found, returns the logical index of 'value' in the sorted list i.e index of the first element greater than value.
            In case of duplicates it returns the index of the first one.
            It guarantees that items before the returned index are &lt; value, while those at and after the returned index are &gt;= value.
            </summary>
        </member>
        <member name="M:Microsoft.ML.Internal.Utilities.Utils.FindIndexSorted(System.ReadOnlySpan{System.Int32},System.Int32,System.Int32,System.Int32)">
            <summary>
            Assumes input is sorted and finds value using BinarySearch.
            If value is not found, returns the logical index of 'value' in the sorted list i.e index of the first element greater than value.
            In case of duplicates it returns the index of the first one.
            It guarantees that items before the returned index are &lt; value, while those at and after the returned index are &gt;= value.
            </summary>
        </member>
        <member name="M:Microsoft.ML.Internal.Utilities.Utils.FindIndexSorted(System.Collections.Generic.IList{System.Int32},System.Int32,System.Int32,System.Int32)">
            <summary>
            Assumes input is sorted and finds value using BinarySearch.
            If value is not found, returns the logical index of 'value' in the sorted list i.e index of the first element greater than value.
            In case of duplicates it returns the index of the first one.
            It guarantees that items before the returned index are &lt; value, while those at and after the returned index are &gt;= value.
            </summary>
        </member>
        <member name="M:Microsoft.ML.Internal.Utilities.Utils.FindIndexSorted(System.Collections.Generic.IList{System.Single},System.Int32,System.Int32,System.Single)">
            <summary>
            Assumes input is sorted and finds value using BinarySearch.
            If value is not found, returns the logical index of 'value' in the sorted list i.e index of the first element greater than value.
            In case of duplicates it returns the index of the first one.
            It guarantees that items before the returned index are &lt; value, while those at and after the returned index are &gt;= value.
            </summary>
        </member>
        <member name="M:Microsoft.ML.Internal.Utilities.Utils.FindIndexSorted(System.Double[],System.Int32,System.Int32,System.Double)">
            <summary>
            Assumes input is sorted and finds value using BinarySearch.
            If value is not found, returns the logical index of 'value' in the sorted list i.e index of the first element greater than value.
            In case of duplicates it returns the index of the first one.
            It guarantees that items before the returned index are &lt; value, while those at and after the returned index are &gt;= value.
            </summary>
        </member>
        <member name="M:Microsoft.ML.Internal.Utilities.Utils.FindIndexSorted``1(``0[],System.Int32,System.Int32,System.Func{``0,System.Boolean})">
            <summary>
            Finds the unique index for which func(input[i]) == false whenever i &lt; index and
            func(input[i]) == true whenever i &gt;= index.
            Callers should guarantee that there is such an index. Uses binary search.
            </summary>
        </member>
        <member name="M:Microsoft.ML.Internal.Utilities.Utils.FindIndexSorted``2(``0[],System.Int32,System.Int32,System.Func{``0,``1,System.Boolean},``1)">
            <summary>
            Finds the unique index for which func(input[i], value) == false whenever i &lt; index and
            func(input[i], value) == true whenever i &gt;= index.
            Callers should guarantee that there is such an index. Uses binary search.
            </summary>
        </member>
        <member name="M:Microsoft.ML.Internal.Utilities.Utils.IsMonotonicallyIncreasing(System.Collections.Generic.IList{System.Single})">
            <summary>
            Checks that an input IList is monotonically increasing.
            </summary>
            <param name="values">An array of values</param>
            <returns>True if the array is monotonically increasing (if each element is greater
            than or equal to previous elements); false otherwise. ILists containing NaN values
            are considered to be not monotonically increasing.</returns>
        </member>
        <member name="M:Microsoft.ML.Internal.Utilities.Utils.IsMonotonicallyIncreasing(System.Collections.Generic.IList{System.Int32})">
            <summary>
            Checks that an input array is monotonically increasing.
            </summary>
            <param name="values">An array of values</param>
            <returns>True if the array is monotonically increasing (if each element is greater
            than or equal to previous elements); false otherwise.</returns>
        </member>
        <member name="M:Microsoft.ML.Internal.Utilities.Utils.IsMonotonicallyIncreasing(System.Collections.Generic.IList{System.Double})">
            <summary>
            Checks that an input array is monotonically increasing.
            </summary>
            <param name="values">An array of values</param>
            <returns>True if the array is monotonically increasing (if each element is greater
            than or equal to previous elements); false otherwise. Arrays containing NaN values
            are considered to be not monotonically increasing.</returns>
        </member>
        <member name="M:Microsoft.ML.Internal.Utilities.Utils.IsIncreasing(System.Int32,System.ReadOnlySpan{System.Int32},System.Int32)">
            <summary>
            Returns whether an input integer vector is sorted and unique,
            and between an inclusive lower and exclusive upper bound for
            the first and last items, respectively.
            </summary>
        </member>
        <member name="M:Microsoft.ML.Internal.Utilities.Utils.IsIncreasing(System.Int32,System.ReadOnlySpan{System.Int32},System.Int32,System.Int32)">
            <summary>
            Returns whether an input integer vector up to <paramref name="len"/>
            is sorted and unique, and between an inclusive lower and exclusive
            upper bound for the first and last items, respectively.
            </summary>
        </member>
        <member name="M:Microsoft.ML.Internal.Utilities.Utils.CreateArray``1(System.Int32,``0)">
            <summary>
            Create an array of specified length, filled with a specified value
            </summary>
        </member>
        <member name="M:Microsoft.ML.Internal.Utilities.Utils.BuildSubsetMaps(System.Int32,System.Func{System.Int32,System.Boolean},System.Int32[]@,System.Int32[]@)">
            <summary>
            Given a predicate, over a range of values defined by a limit calculate
            first the values for which that predicate was true, and second an inverse
            map.
            </summary>
            <param name="lim">Indicates the exclusive upper bound on the tested values</param>
            <param name="pred">The predicate to test for various value</param>
            <param name="map">An ascending array of values from 0 inclusive
            to <paramref name="lim"/> exclusive, holding all values for which
            <paramref name="pred"/> is true</param>
            <param name="invMap">Forms an inverse mapping of <paramref name="map"/>,
            so that <c><paramref name="invMap"/>[<paramref name="map"/>[i]] == i</c>,
            and for other entries not appearing in <paramref name="map"/>,
            <c><paramref name="invMap"/>[i] == -1</c></param>
        </member>
        <member name="M:Microsoft.ML.Internal.Utilities.Utils.BuildSubsetMaps(System.Int32,System.Collections.Generic.IEnumerable{Microsoft.Data.DataView.DataViewSchema.Column},System.Int32[]@,System.Int32[]@)">
            <summary>
            Given the columns needed, over a range of values defined by a limit calculate
            first the values for which the column is present was true, and second an inverse
            map.
            </summary>
            <param name="lim">Indicates the exclusive upper bound on the tested values</param>
            <param name="columnsNeeded">The set of columns the calling component operates on.</param>
            <param name="map">An ascending array of values from 0 inclusive
            to <paramref name="lim"/> exclusive, holding all values for which
            <paramref name="columnsNeeded"/> are present.
            (The respective index appears in the <paramref name="columnsNeeded"/> collection).</param>
            <param name="invMap">Forms an inverse mapping of <paramref name="map"/>,
            so that <c><paramref name="invMap"/>[<paramref name="map"/>[i]] == i</c>,
            and for other entries not appearing in <paramref name="map"/>,
            <c><paramref name="invMap"/>[i] == -1</c></param>
        </member>
        <member name="M:Microsoft.ML.Internal.Utilities.Utils.EnsureSize``1(``0[]@,System.Int32,System.Boolean)">
            <summary>
            Resizes the array if necessary, to ensure that it has at least <paramref name="min"/> elements.
            </summary>
            <param name="array">The array to resize. Can be null.</param>
            <param name="min">The minimum number of items the new array must have.</param>
            <param name="keepOld">True means that the old array is preserved, if possible (Array.Resize is called). False
            means that a new array will be allocated.
            </param>
            <returns>The new size, that is no less than <paramref name="min"/>.</returns>
        </member>
        <member name="M:Microsoft.ML.Internal.Utilities.Utils.EnsureSize``1(``0[]@,System.Int32,System.Int32,System.Boolean)">
            <summary>
            Resizes the array if necessary, to ensure that it has at least <paramref name="min"/> and at most <paramref name="max"/> elements.
            </summary>
            <param name="array">The array to resize. Can be null.</param>
            <param name="min">The minimum number of items the new array must have.</param>
            <param name="max">The maximum number of items the new array can have.</param>
            <param name="keepOld">True means that the old array is preserved, if possible (Array.Resize is called). False
            means that a new array will be allocated.
            </param>
            <returns>The new size, that is no less than <paramref name="min"/> and no more that <paramref name="max"/>.</returns>
        </member>
        <member name="M:Microsoft.ML.Internal.Utilities.Utils.GetCardinality(System.Collections.BitArray)">
            <summary>
            Returns the number of set bits in a bit array.
            </summary>
        </member>
        <member name="M:Microsoft.ML.Internal.Utilities.Utils.MarshalInvoke``1(System.Func{``0},System.Type)">
             <summary>
             Given a generic method with a single type parameter, re-create the generic method on a new type,
             then reinvoke the method and return the result. A common pattern throughout the code base is to
             have some sort of generic method, whose parameters and return value are, as defined, non-generic,
             but whose code depends on some sort of generic type parameter. This utility method exists to make
             this common pattern more convenient, and also safer so that the arguments, if any, can be type
             checked at compile time instead of at runtime.
            
             Because it is strongly typed, this can only be applied to methods whose return type
             is known at compile time, that is, that do not depend on the type parameter of the method itself.
             </summary>
             <typeparam name="TRet">The return value</typeparam>
             <param name="func">A delegate that should be a generic method with a single type parameter.
             The generic method definition will be extracted, then a new method will be created with the
             given type parameter, then the method will be invoked.</param>
             <param name="genArg">The new type parameter for the generic method</param>
             <returns>The return value of the invoked function</returns>
        </member>
        <member name="M:Microsoft.ML.Internal.Utilities.Utils.MarshalInvoke``2(System.Func{``0,``1},System.Type,``0)">
            <summary>
            A one-argument version of <see cref="M:Microsoft.ML.Internal.Utilities.Utils.MarshalInvoke``1(System.Func{``0},System.Type)"/>.
            </summary>
        </member>
        <member name="M:Microsoft.ML.Internal.Utilities.Utils.MarshalInvoke``3(System.Func{``0,``1,``2},System.Type,``0,``1)">
            <summary>
            A two-argument version of <see cref="M:Microsoft.ML.Internal.Utilities.Utils.MarshalInvoke``1(System.Func{``0},System.Type)"/>.
            </summary>
        </member>
        <member name="M:Microsoft.ML.Internal.Utilities.Utils.MarshalInvoke``4(System.Func{``0,``1,``2,``3},System.Type,``0,``1,``2)">
            <summary>
            A three-argument version of <see cref="M:Microsoft.ML.Internal.Utilities.Utils.MarshalInvoke``1(System.Func{``0},System.Type)"/>.
            </summary>
        </member>
        <member name="M:Microsoft.ML.Internal.Utilities.Utils.MarshalInvoke``5(System.Func{``0,``1,``2,``3,``4},System.Type,``0,``1,``2,``3)">
            <summary>
            A four-argument version of <see cref="M:Microsoft.ML.Internal.Utilities.Utils.MarshalInvoke``1(System.Func{``0},System.Type)"/>.
            </summary>
        </member>
        <member name="M:Microsoft.ML.Internal.Utilities.Utils.MarshalInvoke``6(System.Func{``0,``1,``2,``3,``4,``5},System.Type,``0,``1,``2,``3,``4)">
            <summary>
            A five-argument version of <see cref="M:Microsoft.ML.Internal.Utilities.Utils.MarshalInvoke``1(System.Func{``0},System.Type)"/>.
            </summary>
        </member>
        <member name="M:Microsoft.ML.Internal.Utilities.Utils.MarshalInvoke``7(System.Func{``0,``1,``2,``3,``4,``5,``6},System.Type,``0,``1,``2,``3,``4,``5)">
            <summary>
            A six-argument version of <see cref="M:Microsoft.ML.Internal.Utilities.Utils.MarshalInvoke``1(System.Func{``0},System.Type)"/>.
            </summary>
        </member>
        <member name="M:Microsoft.ML.Internal.Utilities.Utils.MarshalInvoke``8(System.Func{``0,``1,``2,``3,``4,``5,``6,``7},System.Type,``0,``1,``2,``3,``4,``5,``6)">
            <summary>
            A seven-argument version of <see cref="M:Microsoft.ML.Internal.Utilities.Utils.MarshalInvoke``1(System.Func{``0},System.Type)"/>.
            </summary>
        </member>
        <member name="M:Microsoft.ML.Internal.Utilities.Utils.MarshalInvoke``9(System.Func{``0,``1,``2,``3,``4,``5,``6,``7,``8},System.Type,``0,``1,``2,``3,``4,``5,``6,``7)">
            <summary>
            An eight-argument version of <see cref="M:Microsoft.ML.Internal.Utilities.Utils.MarshalInvoke``1(System.Func{``0},System.Type)"/>.
            </summary>
        </member>
        <member name="M:Microsoft.ML.Internal.Utilities.Utils.MarshalInvoke``10(System.Func{``0,``1,``2,``3,``4,``5,``6,``7,``8,``9},System.Type,``0,``1,``2,``3,``4,``5,``6,``7,``8)">
            <summary>
            A nine-argument version of <see cref="M:Microsoft.ML.Internal.Utilities.Utils.MarshalInvoke``1(System.Func{``0},System.Type)"/>.
            </summary>
        </member>
        <member name="M:Microsoft.ML.Internal.Utilities.Utils.MarshalInvoke``11(System.Func{``0,``1,``2,``3,``4,``5,``6,``7,``8,``9,``10},System.Type,``0,``1,``2,``3,``4,``5,``6,``7,``8,``9)">
            <summary>
            A ten-argument version of <see cref="M:Microsoft.ML.Internal.Utilities.Utils.MarshalInvoke``1(System.Func{``0},System.Type)"/>.
            </summary>
        </member>
        <member name="M:Microsoft.ML.Internal.Utilities.Utils.MarshalActionInvoke(System.Action,System.Type)">
            <summary>
            This is akin to <see cref="M:Microsoft.ML.Internal.Utilities.Utils.MarshalInvoke``1(System.Func{``0},System.Type)"/>, except applied to
            <see cref="T:System.Action"/> instead of <see cref="T:System.Func`1"/>.
            </summary>
            <param name="act">A delegate that should be a generic method with a single type parameter.
            The generic method definition will be extracted, then a new method will be created with the
            given type parameter, then the method will be invoked.</param>
            <param name="genArg">The new type parameter for the generic method</param>
        </member>
        <member name="M:Microsoft.ML.Internal.Utilities.Utils.MarshalActionInvoke``1(System.Action{``0},System.Type,``0)">
            <summary>
            A one-argument version of <see cref="M:Microsoft.ML.Internal.Utilities.Utils.MarshalActionInvoke(System.Action,System.Type)"/>.
            </summary>
        </member>
        <member name="M:Microsoft.ML.Internal.Utilities.Utils.MarshalActionInvoke``2(System.Action{``0,``1},System.Type,``0,``1)">
            <summary>
            A two-argument version of <see cref="M:Microsoft.ML.Internal.Utilities.Utils.MarshalActionInvoke(System.Action,System.Type)"/>.
            </summary>
        </member>
        <member name="M:Microsoft.ML.Internal.Utilities.Utils.MarshalActionInvoke``3(System.Action{``0,``1,``2},System.Type,``0,``1,``2)">
            <summary>
            A three-argument version of <see cref="M:Microsoft.ML.Internal.Utilities.Utils.MarshalActionInvoke(System.Action,System.Type)"/>.
            </summary>
        </member>
        <member name="M:Microsoft.ML.Internal.Utilities.Utils.MarshalActionInvoke``4(System.Action{``0,``1,``2,``3},System.Type,``0,``1,``2,``3)">
            <summary>
            A four-argument version of <see cref="M:Microsoft.ML.Internal.Utilities.Utils.MarshalActionInvoke(System.Action,System.Type)"/>.
            </summary>
        </member>
        <member name="M:Microsoft.ML.Internal.Utilities.CmdIndenter.GetIndentedCommandLine(System.String)">
            <summary>
            Get indented version of command line or same string if we unable to produce it.
            </summary>
            <param name="commandLine">command line</param>
            <returns>indented version of command line(if possible)</returns>
        </member>
        <member name="M:Microsoft.ML.Internal.Utilities.CmdIndenter.TryProduceIndentString(System.String,System.CodeDom.Compiler.IndentedTextWriter)">
            <summary>
            Try produce indented string for command line.
            </summary>
            <param name="text">command line</param>
            <param name="itw">indenting text writer</param>
            <returns>true if we was able to produce indented string without any problem</returns>
        </member>
        <member name="T:Microsoft.ML.Internal.Utilities.DoubleParser.Result">
            <summary>
            Result codes from Parse methods. Note that the order matters.
            </summary>
        </member>
        <member name="F:Microsoft.ML.Internal.Utilities.DoubleParser.Result.Good">
            <summary>
            No issues.
            </summary>
        </member>
        <member name="F:Microsoft.ML.Internal.Utilities.DoubleParser.Result.Empty">
            <summary>
            Empty or only whitespace
            </summary>
        </member>
        <member name="F:Microsoft.ML.Internal.Utilities.DoubleParser.Result.Extra">
            <summary>
            Extra non-whitespace characters after successful parse
            </summary>
        </member>
        <member name="F:Microsoft.ML.Internal.Utilities.DoubleParser.Result.Error">
            <summary>
            Parsing error
            </summary>
        </member>
        <member name="M:Microsoft.ML.Internal.Utilities.DoubleParser.TryParse(System.ReadOnlySpan{System.Char},System.Single@)">
            <summary>
            This produces zero for an empty string.
            </summary>
        </member>
        <member name="M:Microsoft.ML.Internal.Utilities.DoubleParser.TryParse(System.ReadOnlySpan{System.Char},System.Double@)">
            <summary>
            This produces zero for an empty string.
            </summary>
        </member>
        <member name="T:Microsoft.ML.Internal.Utilities.FixedSizeQueue`1">
            <summary>
            A fixed-length circular array. Items are added at the end. If the array is full, adding
             an item will result in discarding the least recently added item.
            </summary>
        </member>
        <member name="T:Microsoft.ML.Internal.Utilities.HashArray`1">
            <summary>
            A Hash Array that implements both val -> index lookup and index -> val lookup.
            Also implements memory efficient sorting.
            Note: Supports adding and looking up of items but does not support removal of items.
            </summary>
        </member>
        <member name="M:Microsoft.ML.Internal.Utilities.HashArray`1.TryGetIndex(`0,System.Int32@)">
            <summary>
            Find the index of the given val in the hash array.
            Returns a bool representing if val is present.
            Index outputs the index that the val is at in the array, -1 otherwise.
            </summary>
        </member>
        <member name="M:Microsoft.ML.Internal.Utilities.HashArray`1.Add(`0)">
            <summary>
            Make sure the given value has an equivalent TItem in the hashArray
            and return the index of the value.
            </summary>
        </member>
        <member name="M:Microsoft.ML.Internal.Utilities.HashArray`1.TryAdd(`0)">
            <summary>
            Make sure the given value has an equivalent TItem in the hashArray
            and return the index of the value.
            </summary>
        </member>
        <member name="M:Microsoft.ML.Internal.Utilities.HashArray`1.AddCore(`0,System.Int32)">
            <summary>
            Adds the value as a TItem. Does not check whether the TItem is already present.
            Returns the index of the added value.
            </summary>
        </member>
        <member name="M:Microsoft.ML.Internal.Utilities.HashArray`1.FillTable">
            <summary>
            Appropriately fills _rgnext and _rgit based on _rgt and _rghash.
            </summary>
        </member>
        <member name="M:Microsoft.ML.Internal.Utilities.HashArray`1.CopyTo(System.Span{`0})">
            <summary>
            Copies all items to the passed in span. Requires the passed in span to be at least the
            same length as Count.
            </summary>
        </member>
        <member name="M:Microsoft.ML.Internal.Utilities.Hashing.CombinedHash(System.Int32,System.Object[])">
            <summary>
            Creates a combined hash of possibly heterogenously typed values.
            </summary>
            <param name="startHash">The leading hash, incorporated into the final hash</param>
            <param name="os">A variable list of objects, where null is a valid value</param>
            <returns>The combined hash incorpoating a starting hash, and the hash codes
            of all input values</returns>
        </member>
        <member name="M:Microsoft.ML.Internal.Utilities.Hashing.CombinedHash``1(System.Int32,``0[])">
            <summary>
            Creates a combined hash of multiple homogenously typed non-null values.
            </summary>
            <typeparam name="T">The type of items to hash</typeparam>
            <param name="startHash">The leading hash, incorporated into the final hash</param>
            <param name="os">A variable list of non-null values</param>
            <returns>The combined hash incorpoating a starting hash, and the hash codes
            of all input values</returns>
        </member>
        <member name="M:Microsoft.ML.Internal.Utilities.Hashing.HashString(System.ReadOnlySpan{System.Char})">
            <summary>
            Hash the characters in a <see cref="T:System.ReadOnlySpan`1"/> of <see cref="T:System.Char"/>.
            This MUST produce the same result as the other overloads (with equivalent characters).
            </summary>
        </member>
        <member name="M:Microsoft.ML.Internal.Utilities.Hashing.HashString(System.Text.StringBuilder)">
            <summary>
            Hash the characters in a string builder. This MUST produce the same result
            as HashString(sb.ToString()).
            </summary>
        </member>
        <member name="M:Microsoft.ML.Internal.Utilities.Hashing.MurmurRound(System.UInt32,System.UInt32)">
            <summary>
            Combines the given hash value with a uint value, using the murmur hash 3 algorithm.
            Make certain to also use <see cref="M:Microsoft.ML.Internal.Utilities.Hashing.MixHash(System.UInt32)"/> on the final hashed value, if you
            depend upon having distinct bits.
            </summary>
        </member>
        <member name="M:Microsoft.ML.Internal.Utilities.Hashing.MurmurHash(System.UInt32,System.ReadOnlySpan{System.Char},System.Boolean)">
            <summary>
            Implements the murmur hash 3 algorithm, using a mock UTF-8 encoding.
            The UTF-8 conversion ignores the possibilities of unicode planes other than the 0th.
            That is, it simply converts char values to one, two, or three bytes according to
            the following rules:
            * 0x0000 to 0x007F : 0xxxxxxx
            * 0x0080 to 0x07FF : 110xxxxx 10xxxxxx
            * 0x0800 to 0xFFFF : 1110xxxx 10xxxxxx 10xxxxxx
            NOTE: This MUST match the StringBuilder version below.
            </summary>
        </member>
        <member name="M:Microsoft.ML.Internal.Utilities.Hashing.MurmurHash(System.UInt32,System.Text.StringBuilder,System.Int32,System.Int32,System.Boolean)">
            <summary>
            Implements the murmur hash 3 algorithm, using a mock UTF-8 encoding.
            The UTF-8 conversion ignores the possibilities of unicode planes other than the 0th.
            That is, it simply converts char values to one, two, or three bytes according to
            the following rules:
            * 0x0000 to 0x007F : 0xxxxxxx
            * 0x0080 to 0x07FF : 110xxxxx 10xxxxxx
            * 0x0800 to 0xFFFF : 1110xxxx 10xxxxxx 10xxxxxx
            NOTE: This MUST match the string version above.
            </summary>
        </member>
        <member name="M:Microsoft.ML.Internal.Utilities.Hashing.MurmurHash(System.UInt32,System.UInt32[],System.Int32,System.Int32)">
            <summary>
            Performs a MurmurRound on each int in the sequence
            </summary>
        </member>
        <member name="M:Microsoft.ML.Internal.Utilities.Hashing.MixHash(System.UInt32)">
            <summary>
            The final mixing ritual for the Murmur3 hashing algorithm. Most users of
            <see cref="M:Microsoft.ML.Internal.Utilities.Hashing.MurmurRound(System.UInt32,System.UInt32)"/> will want to close their progressive building of
            a hash with a call to this method.
            </summary>
        </member>
        <member name="T:Microsoft.ML.Internal.Utilities.Heap`1">
            <summary>
            Implements a heap.
            </summary>
        </member>
        <member name="M:Microsoft.ML.Internal.Utilities.Heap`1.#ctor(System.Func{`0,`0,System.Boolean})">
            <summary>
            A Heap structure gives efficient access to the ordered next element.
            </summary>
            <param name="fnReverse">A delegate that takes two <c>T</c> objects, and if
            it returns true then the second object should be popped before the first</param>
        </member>
        <member name="M:Microsoft.ML.Internal.Utilities.Heap`1.#ctor(System.Func{`0,`0,System.Boolean},System.Int32)">
            <summary>
            A Heap structure gives efficient access to the ordered next element.
            </summary>
            <param name="fnReverse">A delegate that takes two <c>T</c> objects, and if
            it returns true then the second object should be popped before the first</param>
            <param name="capacity">The initial capacity of the heap</param>
        </member>
        <member name="P:Microsoft.ML.Internal.Utilities.Heap`1.FnReverse">
            <summary> Func tests true if first element should be after the second
            </summary>
        </member>
        <member name="P:Microsoft.ML.Internal.Utilities.Heap`1.Count">
            <summary>
            Current count of elements remaining in the heap
            </summary>
        </member>
        <member name="M:Microsoft.ML.Internal.Utilities.Heap`1.Clear">
            <summary>
            Discard all elements currently in the heap
            </summary>
        </member>
        <member name="P:Microsoft.ML.Internal.Utilities.Heap`1.Top">
            <summary>
            Peek at the first element in the heap
            </summary>
        </member>
        <member name="M:Microsoft.ML.Internal.Utilities.Heap`1.Pop">
            <summary>
            Remove and return the first element in the heap
            </summary>
            <returns>The first element in the heap</returns>
        </member>
        <member name="M:Microsoft.ML.Internal.Utilities.Heap`1.Add(`0)">
            <summary>
            Add a new element to the heap
            </summary>
            <param name="item">The item to add</param>
        </member>
        <member name="T:Microsoft.ML.Internal.Utilities.HeapNode">
            <summary>
            For the heap to allow deletion, the heap node has to derive from this class.
            </summary>
        </member>
        <member name="T:Microsoft.ML.Internal.Utilities.HeapNode.Heap`1">
            <summary>
            Implements a heap.
            </summary>
        </member>
        <member name="M:Microsoft.ML.Internal.Utilities.HeapNode.Heap`1.#ctor(System.Func{`0,`0,System.Boolean})">
            <summary>
            A Heap structure gives efficient access to the ordered next element.
            </summary>
            <param name="fnReverse">A delegate that takes two <c>T</c> objects, and if
            it returns true then the second object should be popped before the first</param>
        </member>
        <member name="M:Microsoft.ML.Internal.Utilities.HeapNode.Heap`1.#ctor(System.Func{`0,`0,System.Boolean},System.Int32)">
            <summary>
            A Heap structure gives efficient access to the ordered next element.
            </summary>
            <param name="fnReverse">A delegate that takes two <c>T</c> objects, and if
            it returns true then the second object should be popped before the first</param>
            <param name="capacity">The initial capacity of the heap</param>
        </member>
        <member name="P:Microsoft.ML.Internal.Utilities.HeapNode.Heap`1.FnReverse">
            <summary> Func tests true if first element should be after the second
            </summary>
        </member>
        <member name="P:Microsoft.ML.Internal.Utilities.HeapNode.Heap`1.Count">
            <summary>
            Current count of elements remaining in the heap
            </summary>
        </member>
        <member name="M:Microsoft.ML.Internal.Utilities.HeapNode.Heap`1.Clear">
            <summary>
            Remove all elements currently in the heap
            </summary>
        </member>
        <member name="P:Microsoft.ML.Internal.Utilities.HeapNode.Heap`1.Top">
            <summary>
            Peek at the first element in the heap
            </summary>
        </member>
        <member name="M:Microsoft.ML.Internal.Utilities.HeapNode.Heap`1.Pop">
            <summary>
            Remove and return the first element in the heap
            </summary>
        </member>
        <member name="M:Microsoft.ML.Internal.Utilities.HeapNode.Heap`1.Add(`0)">
            <summary>
            Add a new element to the heap
            </summary>
        </member>
        <member name="M:Microsoft.ML.Internal.Utilities.HeapNode.Heap`1.Delete(`0)">
            <summary>
            Remove an element from the heap
            </summary>
        </member>
        <member name="T:Microsoft.ML.Internal.Utilities.HybridMemoryStream">
            <summary>
            This is a read-write stream that, at or below a length threshold given in the constructor,
            works purely in memory, but if it ever grows larger than that point backs off to use the
            file system. This can be useful if we have intermediate operations that require streams.
            The temporary file will be destroyed if the object is properly disposed.
            </summary>
        </member>
        <member name="M:Microsoft.ML.Internal.Utilities.HybridMemoryStream.#ctor(System.Int32)">
            <summary>
            Constructs an initially empty read-write stream. Once the number of
            bytes in the stream exceeds <paramref name="maxLen"/>,
            then we back off to disk.
            </summary>
            <param name="maxLen">The maximum length we will accomodate in memory</param>
        </member>
        <member name="M:Microsoft.ML.Internal.Utilities.HybridMemoryStream.CreateCache(System.IO.Stream,System.Int32)">
            <summary>
            A common usecase of the hybrid memory stream is to create a persistent
            readable (not necessarily writable) copy of a stream whose source is very
            transient and temporary. This utility method makes that creation of a copy
            somewhat easier.
            </summary>
            <param name="stream">A stream that can be opened</param>
            <param name="maxLen">The maximum length we will accomodate in memory</param>
            <returns>A readable copy of the data stream</returns>
        </member>
        <member name="M:Microsoft.ML.Internal.Utilities.HybridMemoryStream.EnsureOverflow">
            <summary>
            Creates the overflow stream if it does not exist, switching all content over to
            the file-based stream and disposing of the memory stream. If the overflow stream
            already exists, this method has no effect.
            </summary>
        </member>
        <member name="M:Microsoft.ML.Internal.Utilities.LineParser.AllocateFixedSizeArrayToStoreParsedValues(System.ReadOnlySpan{System.Char})">
            <summary>
            we count the number of values first to allocate a single array with of proper size
            </summary>
        </member>
        <member name="T:Microsoft.ML.Internal.Utilities.LruCache`2">
            <summary>
            Implements a least recently used cache.
            </summary>
        </member>
        <member name="P:Microsoft.ML.Internal.Utilities.LruCache`2.Keys">
            <summary>
            Returns the keys of the items stored in the cache, sorted from the most recently used
            to the least recently used.
            </summary>
        </member>
        <member name="M:Microsoft.ML.Internal.Utilities.LruCache`2.#ctor(System.Int32)">
            <summary>
            Initializes a new LRU cache with a given size.
            The class is not thread safe.
            </summary>
        </member>
        <member name="M:Microsoft.ML.Internal.Utilities.LruCache`2.TryGetValue(`0,`1@)">
            <summary>
            Looks up and returns an item. If the item is found, mark it as recently used.
            </summary>
        </member>
        <member name="M:Microsoft.ML.Internal.Utilities.LruCache`2.Add(`0,`1)">
            <summary>
            Adds a new item in the cache. It will be marked as recently used. If the cache
            would grow over the max size, the least recently used item is removed.
            </summary>
        </member>
        <member name="T:Microsoft.ML.Internal.Utilities.MathUtils">
            <summary>
            Some useful math methods.
            </summary>
        </member>
        <member name="M:Microsoft.ML.Internal.Utilities.MathUtils.SimpleLinearRegression(System.Single[],System.Single[],System.Single@,System.Single@)">
            <summary>
            Finds the best least-squares fit of y = ax + b
            </summary>
            <param name="x">The x values.</param>
            <param name="y">The y values.</param>
            <param name="a">The coefficent a.</param>
            <param name="b">The intercept b.</param>
        </member>
        <member name="M:Microsoft.ML.Internal.Utilities.MathUtils.Product(System.Int32[])">
            <summary>
            The product of elements in a
            </summary>
            <param name="a">an array</param>
            <returns>the product of a's elements</returns>
        </member>
        <member name="M:Microsoft.ML.Internal.Utilities.MathUtils.Max(System.Single[])">
            <summary>
            Find the max element of a
            </summary>
            <param name="a">an array</param>
            <returns>the max element</returns>
        </member>
        <member name="M:Microsoft.ML.Internal.Utilities.MathUtils.Min(System.Single[])">
            <summary>
            Find the minimum element of a
            </summary>
            <param name="a">an array</param>
            <returns>the minimum element</returns>
        </member>
        <member name="M:Microsoft.ML.Internal.Utilities.MathUtils.ArgMax(System.ReadOnlySpan{System.Single})">
            <summary>
            Finds the first index of the max element of the span.
            NaNs are ignored. If all the elements to consider are NaNs, -1 is
            returned. The caller should distinguish in this case between two
            possibilities:
            1) The number of the element to consider is zero.
            2) All the elements to consider are NaNs.
            </summary>
            <param name="a">The span of floats.</param>
            <returns>the first index of the max element</returns>
        </member>
        <member name="M:Microsoft.ML.Internal.Utilities.MathUtils.ArgMin(System.ReadOnlySpan{System.Single})">
            <summary>
            Finds the first index of the minimum element of the span.
            NaNs are ignored. If all the elements to consider are NaNs, -1 is
            returned. The caller should distinguish in this case between two
            possibilities:
            1) The number of the element to consider is zero.
            2) All the elements to consider are NaNs.
            </summary>
            <param name="a">The span of floats.</param>
            <returns>the first index of the minimum element</returns>
        </member>
        <member name="M:Microsoft.ML.Internal.Utilities.MathUtils.SoftMax(System.ReadOnlySpan{System.Single})">
            <summary>
            computes the "softmax" function: log sum_i exp x_i
            </summary>
            <param name="inputs">Span of numbers to softmax</param>
            <returns>the softmax of the numbers</returns>
            <remarks>may have slightly lower roundoff error if inputs are sorted, smallest first</remarks>
        </member>
        <member name="M:Microsoft.ML.Internal.Utilities.MathUtils.SoftMax(System.Single,System.Single)">
            <summary>
            computes "softmax" function of two arguments: log (exp x + exp y)
            </summary>
        </member>
        <member name="M:Microsoft.ML.Internal.Utilities.MathUtils.AlmostEqual(System.Single,System.Single)">
            <summary>
            true if two Float values are close (using relative comparison)
            </summary>
            <param name="a"></param>
            <param name="b"></param>
            <returns></returns>
        </member>
        <member name="M:Microsoft.ML.Internal.Utilities.MathUtils.LogGamma(System.Double)">
            <summary>
            Returns the log of the gamma function, using the Stirling approximation
            </summary>
            <param name="x">Argument of function</param>
            <returns>Log Gamma(x)</returns>
            <remarks>Accurate to eight digits for all x.</remarks>
        </member>
        <member name="M:Microsoft.ML.Internal.Utilities.MathUtils.LogFactorial(System.Int32)">
            <summary>
            Computes the log factorial of n, using fast methods
            </summary>
            <param name="n">The number to compute the factorial of</param>
            <returns>The log factorial of n</returns>
        </member>
        <member name="M:Microsoft.ML.Internal.Utilities.MathUtils.TStatisticToPValue(System.Double,System.Double)">
            <summary>
            Returns the two-tailed p-value given a t statistic from a distribution
            parameterized by the provided number of degrees of freedom.
            </summary>
            <param name="t">The t-statistic</param>
            <param name="df">The degrees of freedom</param>
            <returns>The corresponding two-tailed p-value</returns>
        </member>
        <member name="M:Microsoft.ML.Internal.Utilities.MathUtils.Lentz(Microsoft.ML.Internal.Utilities.MathUtils.Sequence,Microsoft.ML.Internal.Utilities.MathUtils.Sequence,System.Double)">
            <summary>
            Lentz's algorithm for evaluating the continued fraction
            b0 + a1 / (b1 + a2 / (b2 + a3 / (b3 + a4 / ...) ) )
            </summary>
            <param name="a">The <c>a</c> function mapping positive integers to a sequence term</param>
            <param name="b">The <c>b</c> function mapping non-negative integers to a sequence term</param>
            <param name="tol">Calculate the continued fraction to this tolerance</param>
            <returns>The evaluation of the continued fraction</returns>
        </member>
        <member name="M:Microsoft.ML.Internal.Utilities.MathUtils.Sigmoid(System.Single)">
            <summary>
            The logistic sigmoid function: 1 / (1 + e^(-x)).
            </summary>
        </member>
        <member name="M:Microsoft.ML.Internal.Utilities.MathUtils.Tanh(System.Single)">
            <summary>
            Hyperbolic tangent.
            </summary>
        </member>
        <member name="M:Microsoft.ML.Internal.Utilities.MathUtils.SigmoidSlow(System.Single)">
            <summary>
            The logistic sigmoid function: 1 / (1 + e^(-x)).
            </summary>
        </member>
        <member name="M:Microsoft.ML.Internal.Utilities.MathUtils.TanhSlow(System.Single)">
            <summary>
            Hyperbolic tangent.
            </summary>
        </member>
        <member name="M:Microsoft.ML.Internal.Utilities.MathUtils.ExpSlow(System.Single)">
            <summary>
            The exponential function: e^(x).
            </summary>
        </member>
        <member name="M:Microsoft.ML.Internal.Utilities.MathUtils.SigmoidFast(System.Single)">
            <summary>
            The logistic sigmoid function: 1 / (1 + e^(-x)).
            </summary>
        </member>
        <member name="M:Microsoft.ML.Internal.Utilities.MathUtils.TanhFast(System.Single)">
            <summary>
            The hyperbolic tangent function.
            </summary>
        </member>
        <member name="M:Microsoft.ML.Internal.Utilities.MathUtils.ExpFast(System.Single)">
            <summary>
            The exponential function: e^(x).
            </summary>
        </member>
        <member name="M:Microsoft.ML.Internal.Utilities.MathUtils.ApplySoftMax(System.Single[],System.Single[])">
            <summary>
            Apply a soft max on an array of Floats. Note that src and dst may be the same array.
            </summary>
        </member>
        <member name="M:Microsoft.ML.Internal.Utilities.MathUtils.ApplySoftMax(System.Single[],System.Single[],System.Int32,System.Int32)">
            <summary>
            Apply a soft max on a range within an array of Floats. Note that src and dst may be the same array.
            </summary>
        </member>
        <member name="M:Microsoft.ML.Internal.Utilities.MathUtils.Entropy(System.Double,System.Boolean)">
            <summary>
            Entropy of a given probability
            </summary>
        </member>
        <member name="M:Microsoft.ML.Internal.Utilities.MathUtils.CrossEntropy(System.Double,System.Double,System.Boolean)">
            <summary>
            Cross-entropy of two distributions
            </summary>
        </member>
        <member name="M:Microsoft.ML.Internal.Utilities.MathUtils.LnSum(System.Collections.Generic.IEnumerable{System.Single})">
            <summary>
            Given a set of values <c>Ln(a1), Ln(a2), ... Ln(an)</c>,
            return <c>Ln(a1+a2+...+an)</c>. This is especially useful
            when working with log probabilities and likelihoods.
            </summary>
            <param name="terms"></param>
        </member>
        <member name="M:Microsoft.ML.Internal.Utilities.MathUtils.Sin(System.Double)">
            <summary>
            Math.Sin returns the input value for inputs with large magnitude. We return NaN instead, for consistency
            with Math.Sin(infinity).
            </summary>
        </member>
        <member name="M:Microsoft.ML.Internal.Utilities.MathUtils.Cos(System.Double)">
            <summary>
            Math.Cos returns the input value for inputs with large magnitude. We return NaN instead, for consistency
            with Math.Cos(infinity).
            </summary>
        </member>
        <member name="M:Microsoft.ML.Internal.Utilities.MathUtils.DivisionCeiling(System.Int64,System.Int64)">
            <summary>
            Returns the smallest integral value that is greater than or equal to the result of the division.
            </summary>
            <param name="numerator">Number to be divided.</param>
            <param name="denomenator">Number with which to divide the numerator.</param>
            <returns></returns>
        </member>
        <member name="M:Microsoft.ML.Internal.Utilities.MatrixTransposeOps.TransposeSingleThread``1(``0[],``0[],System.Int32,System.Int32)">
            <summary>
            Swap the first m*n elements within a given array so that, for any
            non-negative i and j less than m and n respectively, dst[i*n+j] == src[j*m+i].
            This variant of the function is single threaded, and useful in that
            case where the workflow is otherwise single threaded.
            </summary>
            <typeparam name="T">Elements of the array are this type</typeparam>
            <param name="src"></param>
            <param name="dst">Where to write the transpose. Note that dst cannot be the same as src.</param>
            <param name="m"></param>
            <param name="n"></param>
        </member>
        <member name="M:Microsoft.ML.Internal.Utilities.MatrixTransposeOps.Transpose``1(``0[],``0[],System.Int32,System.Int32)">
            <summary>
            Swap the first m*n elements within a given array so that, for any
            non-negative i and j less than m and n respectively, dst[i*n+j] == src[j*m+i]
            </summary>
            <typeparam name="T">Elements of the array are this type</typeparam>
            <param name="src">The source elements of the transpose. Must contain at least m*n elements.</param>
            <param name="dst">Where to write the transpose. Note that dst cannot be the same as src. Must contain at least m*n elements.</param>
            <param name="m">The major index.</param>
            <param name="n">The minor index. Elements are currently stored in "m" blocks of "n" items.</param>
        </member>
        <member name="M:Microsoft.ML.Internal.Utilities.MatrixTransposeOps.Transpose(System.Single*,System.Single*,System.Int32,System.Int32)">
            <summary>
            Swap the first m*n elements within a given array so that, for any
            non-negative i and j less than m and n respectively, b[i*n+j] == a[j*m+i]
            </summary>
            <param name="src"></param>
            <param name="dst">Where to write the transpose. Note that dst cannot be the same as src.</param>
            <param name="m"></param>
            <param name="n"></param>
        </member>
        <member name="M:Microsoft.ML.Internal.Utilities.MatrixTransposeOps.Transpose(System.Double*,System.Double*,System.Int32,System.Int32)">
            <summary>
            Swap the first m*n elements within a given array so that, for any
            non-negative i and j less than m and n respectively, b[i*n+j] == a[j*m+i]
            </summary>
            <param name="src"></param>
            <param name="dst">Where to write the transpose. Note that dst cannot be the same as src.</param>
            <param name="m"></param>
            <param name="n"></param>
        </member>
        <member name="T:Microsoft.ML.Internal.Utilities.MinWaiter">
             <summary>
             A synchronization primitive meant to address situations where you have a set of
             entities of known count, where you want to iteratively provide critical sections
             for each depending on which comes first, but you do not necessarily know what
             constitutes "first" until all such entities tell you where they stand in line.
            
             The anticipated usage is that whatever entity is using the <see cref="T:Microsoft.ML.Internal.Utilities.MinWaiter"/>
             to synchronize itself, will register itself using <see cref="M:Microsoft.ML.Internal.Utilities.MinWaiter.Register(System.Int64)"/>
             so as to unblock any "lower" waiters as soon as it knows what value it needs to
             wait on, perform whatever local work it can, and when it needs to, wait on the
             event it got when it registered itself. It may then repeat the cycle by
             registering itself for a new event (or, finally, retiring itself through
             <see cref="M:Microsoft.ML.Internal.Utilities.MinWaiter.Retire"/>).
             </summary>
        </member>
        <member name="T:Microsoft.ML.Internal.Utilities.MinWaiter.WaitStats">
            <summary>
            This is an event-line pair. The intended usage is, when the line
            is the minimum at a point when all waiters have registered, the event
            will be signaled.
            </summary>
        </member>
        <member name="M:Microsoft.ML.Internal.Utilities.MinWaiter.#ctor(System.Int32)">
            <summary>
            Creates a minimum waiter.
            </summary>
            <param name="waiters">The initial number of waiters</param>
        </member>
        <member name="M:Microsoft.ML.Internal.Utilities.MinWaiter.Register(System.Int64)">
             <summary>
             Indicates to the waiter that we want to, at some future point, wait at a given
             position. This object will return a reset event that can be waited on, at the
             point when we actually want to wait. This method itself has the potential to
             signal other events, if by registering ourselves the waiter becomes aware of
             the maximum number of waiters, allowing that waiter to enter its critical state.
            
             If multiple events are associated with the minimum value, then only one will
             be signaled, and the rest will remain unsignaled. Which is chosen is undefined.
             </summary>
        </member>
        <member name="M:Microsoft.ML.Internal.Utilities.MinWaiter.Retire">
            <summary>
            Retires one of the waiters, and return the current maximum number of waiters.
            If it so happens that by retiring this waiter the number of waiters reaches the
            maximum, the appropriate waiter will be signaled as described in <see cref="M:Microsoft.ML.Internal.Utilities.MinWaiter.Register(System.Int64)"/>.
            </summary>
        </member>
        <member name="T:Microsoft.ML.Internal.Utilities.NormStr">
            <summary>
            Normalized string type. For string pooling.
            </summary>
        </member>
        <member name="M:Microsoft.ML.Internal.Utilities.NormStr.#ctor(System.ReadOnlyMemory{System.Char},System.Int32,System.UInt32)">
            <summary>
            NormStr's can only be created by the Pool.
            </summary>
        </member>
        <member name="M:Microsoft.ML.Internal.Utilities.NormStr.Pool.Get(System.String,System.Boolean)">
            <summary>
            Find the given string in the pool. If not found, returns null.
            </summary>
        </member>
        <member name="M:Microsoft.ML.Internal.Utilities.NormStr.Pool.Add(System.String)">
            <summary>
            Make sure the given string has an equivalent NormStr in the pool and return it.
            </summary>
        </member>
        <member name="M:Microsoft.ML.Internal.Utilities.NormStr.Pool.Get(System.Text.StringBuilder,System.Boolean)">
            <summary>
            Make sure the given string has an equivalent NormStr in the pool and return it.
            </summary>
        </member>
        <member name="M:Microsoft.ML.Internal.Utilities.NormStr.Pool.Add(System.Text.StringBuilder)">
            <summary>
            Make sure the given string builder has an equivalent NormStr in the pool and return it.
            </summary>
        </member>
        <member name="M:Microsoft.ML.Internal.Utilities.NormStr.Pool.AddCore(System.ReadOnlyMemory{System.Char},System.UInt32)">
            <summary>
            Adds the item. Does NOT check for whether the item is already present.
            </summary>
        </member>
        <member name="T:Microsoft.ML.Internal.Utilities.OrderedWaiter">
             <summary>
             The primary use case for this structure is to impose ordering among
             multiple producer threads, in case one is producing output that one
             wishes to have ordered.
            
             More specifically, the ordered waiter allows a thread to wait on a
             particular position. So if three threads wait on 0, 1, then 2 (in
             any order), the first thread to clear the wait will be 0, then 1 will
             be cleared once incremented, then 2 will be cleared once incremented.
             </summary>
        </member>
        <member name="T:Microsoft.ML.Internal.Utilities.OrderedWaiter.WaitStats">
            <summary>
            This is an event-line pair. The intended usage is, when the line
            is hit by the containing ordered waiter, the thread will be hit.
            </summary>
        </member>
        <member name="M:Microsoft.ML.Internal.Utilities.OrderedWaiter.#ctor(System.Boolean)">
            <summary>
            Creates an ordered waiter.
            </summary>
            <param name="firstCleared">If true, then the first position (that is,
            position 0) will be considered already free to proceed. If not something
            will need to hit increment.</param>
        </member>
        <member name="M:Microsoft.ML.Internal.Utilities.OrderedWaiter.#ctor(System.Int64)">
            <summary>
            Creates an ordered waiter.
            </summary>
            <param name="startPos">If startPos is &gt;= 0 then waiter starts from that position.
            If not something will need to hit increment |startPos| times.</param>
        </member>
        <member name="M:Microsoft.ML.Internal.Utilities.OrderedWaiter.Wait(System.Int64,System.Threading.CancellationToken)">
            <summary>
            Wait on a given position. This will block, until this object has
            <see cref="M:Microsoft.ML.Internal.Utilities.OrderedWaiter.Increment"/> called up to the position indicated. This
            accepts cancellation tokens, but the default cancellation token also
            works.
            </summary>
        </member>
        <member name="M:Microsoft.ML.Internal.Utilities.OrderedWaiter.Increment">
            <summary>
            Moves the waiter to the next position, and signals any waiters waiting at
            or before that position.
            </summary>
        </member>
        <member name="M:Microsoft.ML.Internal.Utilities.OrderedWaiter.IncrementAll">
            <summary>
            Signals all waiters. No more calls to <see cref="M:Microsoft.ML.Internal.Utilities.OrderedWaiter.Increment"/> should be
            attempted.
            </summary>
        </member>
        <member name="M:Microsoft.ML.Internal.Utilities.OrderedWaiter.SignalException(System.Exception)">
            <summary>
            This will signal all the waiters, but cause them to throw an exception.
            </summary>
            <param name="ex">The exception that will be the inner exception, of an
            exception that will throw for all current and subsequent waiters.</param>
        </member>
        <member name="T:Microsoft.ML.Internal.Utilities.PlatformUtils">
            <summary>
            Contains extension methods that aid in building cross platform.
            </summary>
        </member>
        <member name="T:Microsoft.ML.Internal.Utilities.IReservoirSampler`1">
            <summary>
            This is an interface for creating samples of a requested size from a stream of data of type <typeparamref name="T"/>.
            The sample is created in one pass by calling <see cref="M:Microsoft.ML.Internal.Utilities.IReservoirSampler`1.Sample"/> for every data point in the stream. Implementations should have
            a delegate for getting the next data point, which is invoked if the current data point should go into the reservoir.
            </summary>
        </member>
        <member name="P:Microsoft.ML.Internal.Utilities.IReservoirSampler`1.Size">
            <summary>
            If the number of elements sampled is less than the reservoir size, this should return the number of elements sampled.
            Otherwise it should return the reservoir size.
            </summary>
        </member>
        <member name="P:Microsoft.ML.Internal.Utilities.IReservoirSampler`1.NumSampled">
            <summary>
            Returns the number of elements sampled so far.
            </summary>
        </member>
        <member name="M:Microsoft.ML.Internal.Utilities.IReservoirSampler`1.Sample">
            <summary>
            Sample the next data point from the stream.
            </summary>
        </member>
        <member name="M:Microsoft.ML.Internal.Utilities.IReservoirSampler`1.Lock">
            <summary>
            This must be called before any calls to <see cref="M:Microsoft.ML.Internal.Utilities.IReservoirSampler`1.GetSample"/>, and no subsequent calls to <see cref="M:Microsoft.ML.Internal.Utilities.IReservoirSampler`1.Sample"/> can
            be made after that.
            </summary>
        </member>
        <member name="M:Microsoft.ML.Internal.Utilities.IReservoirSampler`1.GetSample">
            <summary>
            Return the elements in the sample.
            </summary>
        </member>
        <member name="T:Microsoft.ML.Internal.Utilities.ReservoirSamplerWithoutReplacement`1">
            <summary>
            This class produces a sample without replacement from a stream of data of type <typeparamref name="T"/>.
            It is instantiated with a delegate that gets the next data point, and builds a reservoir in one pass by calling <see cref="M:Microsoft.ML.Internal.Utilities.ReservoirSamplerWithoutReplacement`1.Sample"/>
            for every data point in the stream. In case the next data point does not get 'picked' into the reservoir, the delegate is not invoked.
            Sampling is done according to the algorithm in this paper: <a href="https://epubs.siam.org/doi/pdf/10.1137/1.9781611972740.53">https://epubs.siam.org/doi/pdf/10.1137/1.9781611972740.53</a>.
            </summary>
        </member>
        <member name="M:Microsoft.ML.Internal.Utilities.ReservoirSamplerWithoutReplacement`1.GetSample">
            <summary>
            Gets the reservoir sample.
            </summary>
        </member>
        <member name="T:Microsoft.ML.Internal.Utilities.ReservoirSamplerWithReplacement`1">
            <summary>
            This class produces a sample with replacement from a stream of data of type <typeparamref name="T"/>.
            It is instantiated with a delegate that gets the next data point, and builds a reservoir in one pass by calling <see cref="M:Microsoft.ML.Internal.Utilities.ReservoirSamplerWithReplacement`1.Sample"/>
            for every data point in the stream. In case the next data point does not get 'picked' into the reservoir, the delegate is not invoked.
            Sampling is done according to the algorithm in this paper: <a href="https://epubs.siam.org/doi/pdf/10.1137/1.9781611972740.53">https://epubs.siam.org/doi/pdf/10.1137/1.9781611972740.53</a>.
            </summary>
        </member>
        <member name="M:Microsoft.ML.Internal.Utilities.ReservoirSamplerWithReplacement`1.GetCache">
            <summary>
            Returns the cache. Users should not change the elements of the returned array.
            Access only elements up to the logical length of the array, which is <see cref="P:Microsoft.ML.Internal.Utilities.ReservoirSamplerWithReplacement`1.Size"/>.
            </summary>
        </member>
        <member name="M:Microsoft.ML.Internal.Utilities.ReservoirSamplerWithReplacement`1.GetSample">
            <summary>
            Gets a reservoir sample with replacement of the elements sampled so far. Users should not change the
            elements returned since multiple elements in the reservoir might be pointing to the same memory.
            </summary>
        </member>
        <member name="T:Microsoft.ML.Internal.Utilities.ResourceManagerUtils">
            <summary>
            This class takes care of downloading resources needed by ML.NET components. Resources are located in
            a pre-defined location, that can be overridden by defining Environment variable <see cref="F:Microsoft.ML.Internal.Utilities.ResourceManagerUtils.CustomResourcesUrlEnvVariable"/>.
            </summary>
        </member>
        <member name="P:Microsoft.ML.Internal.Utilities.ResourceManagerUtils.MlNetResourcesUrl">
            <summary>
            The location of the resources to download from. Uses either the default location or a location defined
            in an Environment variable.
            </summary>
        </member>
        <member name="F:Microsoft.ML.Internal.Utilities.ResourceManagerUtils.TimeoutEnvVariable">
            <summary>
            An environment variable containing a timeout period (in milliseconds) for downloading resources. If defined,
            overrides the timeout defined in the code.
            </summary>
        </member>
        <member name="F:Microsoft.ML.Internal.Utilities.ResourceManagerUtils.CustomResourcesUrlEnvVariable">
            <summary>
            Environment variable containing optional url to download resources from.
            </summary>
        </member>
        <member name="M:Microsoft.ML.Internal.Utilities.ResourceManagerUtils.GetUrl(System.String)">
            <summary>
            Generates a url from a suffix.
            </summary>
        </member>
        <member name="M:Microsoft.ML.Internal.Utilities.ResourceManagerUtils.EnsureResource(Microsoft.ML.IHostEnvironment,Microsoft.ML.IChannel,System.String,System.String,System.String,System.Int32)">
            <summary>
            Returns a <see cref="T:System.Threading.Tasks.Task"/> that tries to download a resource from a specified url, and returns the path to which it was
            downloaded, and an exception if one was thrown.
            </summary>
            <param name="env">The host environment.</param>
            <param name="ch">A channel to provide information about the download.</param>
            <param name="relativeUrl">The relative url from which to download.
            This is appended to the url defined in <see cref="P:Microsoft.ML.Internal.Utilities.ResourceManagerUtils.MlNetResourcesUrl"/>.</param>
            <param name="fileName">The name of the file to save.</param>
            <param name="dir">The directory where the file should be saved to. The file will be saved in a directory with the specified name inside
            a folder called "mlnet-resources" in the <see cref="F:System.Environment.SpecialFolder.ApplicationData"/> directory.</param>
            <param name="timeout">An integer indicating the number of milliseconds to wait before timing out while downloading a resource.</param>
            <returns>The download results, containing the file path where the resources was (or should have been) downloaded to, and an error message
            (or null if there was no error).</returns>
        </member>
        <member name="M:Microsoft.ML.Internal.Utilities.ResourceManagerUtils.DownloadFromUrl(Microsoft.ML.IHostEnvironment,Microsoft.ML.IChannel,System.String,System.String,System.Int32,System.String)">
            <returns>Returns the error message if an error occured, null if download was successful.</returns>
        </member>
        <member name="M:Microsoft.ML.Internal.Utilities.ResourceManagerUtils.GetFilePath(Microsoft.ML.IChannel,System.String,System.String,System.String@)">
            <summary>
            Get the path where the resource should be downloaded to. If the environment variable
            is defined, download to the location defined there. Otherwise, download to the "dir" directory
            inside <see cref="F:System.Environment.SpecialFolder.LocalApplicationData"/>\mlnet-resources\.
            </summary>
        </member>
        <member name="T:Microsoft.ML.Internal.Utilities.Stats">
            <summary>
            A class containing common statistical functions
            </summary>
        </member>
        <member name="M:Microsoft.ML.Internal.Utilities.Stats.SampleLong(System.Int64,System.Random)">
            <summary>
            Returns a number uniformly sampled from 0...(rangeSize-1)
            </summary>
            <param name="rangeSize">Size of range to sample from, between 0 and int.MaxValue^2</param>
            <param name="rand">Random number generator</param>
            <returns>Sampled value</returns>
        </member>
        <member name="M:Microsoft.ML.Internal.Utilities.Stats.SampleFromGaussian(System.Random)">
            <summary>
            Returns a number sampled from a zero-mean, unit variance Gaussian
            </summary>
            <param name="rand">A Random to use for the sampling</param>
            <returns>a sample</returns>
            <remarks>uses Joseph L. Leva's algorithm from "A fast normal random number generator", 1992</remarks>
        </member>
        <member name="M:Microsoft.ML.Internal.Utilities.Stats.SampleFromGamma(System.Random,System.Double)">
            <summary>
            Returns a sample from the gamma distribution with scale parameter 1, shape parameter alpha
            </summary>
            <param name="alpha">Shape parameter</param>
            <param name="r">The random number generator to use</param>
            <returns>Sample from gamma distribution</returns>
            <remarks>Uses Marsaglia and Tsang's fast algorithm</remarks>
        </member>
        <member name="M:Microsoft.ML.Internal.Utilities.Stats.SampleFromBeta(System.Random,System.Double,System.Double)">
            <summary>
            Generates a beta-distributed random variable
            </summary>
            <param name="rand">Random generator to use</param>
            <param name="alpha1">first parameter</param>
            <param name="alpha2">second parameter</param>
            <returns>Sample from distribution</returns>
        </member>
        <member name="M:Microsoft.ML.Internal.Utilities.Stats.SampleFromDirichlet(System.Random,System.Double[],System.Double[])">
            <summary>
            Generates a dirichlet-distributed random variable
            </summary>
            <param name="rand">Random generator to use</param>
            <param name="alphas">array of parameters</param>
            <param name="result">array in which to store resulting sample</param>
        </member>
        <member name="M:Microsoft.ML.Internal.Utilities.Stats.SampleFromCauchy(System.Random)">
            <summary>
            Sample from a standard Cauchy distribution:
            https://en.wikipedia.org/wiki/Lorentzian_function
            </summary>
            <param name="rand"></param>
            <returns></returns>
        </member>
        <member name="M:Microsoft.ML.Internal.Utilities.Stats.SampleFromBinomial(System.Random,System.Int32,System.Double)">
            <summary>
            Returns a number sampled from the binomial distribution with parameters n and p
            </summary>
            <param name="r">Random generator to use</param>
            <param name="n">Parameter N of binomial</param>
            <param name="p">Parameter p of binomial</param>
            <returns></returns>
            <remarks>Should be robust for all values of n, p</remarks>
        </member>
        <member name="T:Microsoft.ML.Internal.Utilities.SubsetStream">
            <summary>
            Returns a "view" stream, which appears to be a possibly truncated
            version of the stream. Reads on this containing stream will also
            advance the wrapped stream. If truncated, reads will not progress
            beyond the indicated length, and writes will fail beyond the
            indicated length. This stream supports seeking (and associated
            operations) if the underlying stream supports seeking, where it is
            supposed that the returned <c>SubsetStream</c> instance has position
            0 during creation, corresponding to whatever the position of the
            enclosed stream was during creation, so this stream will act as an
            "offset" version of the enclosed stream. As this is intended to
            operate over a subset of a stream, during closing or disposal of the
            subset stream, the underlying stream will always remain open and
            undisposed.
            </summary>
        </member>
        <member name="M:Microsoft.ML.Internal.Utilities.SubsetStream.#ctor(System.IO.Stream,System.Nullable{System.Int64})">
            <summary>
            Construct the view stream.
            </summary>
            <param name="stream">The underlying stream</param>
            <param name="length">The maximum length this containing
            stream should appear to have, or null if unbounded</param>
        </member>
        <member name="P:Microsoft.ML.Internal.Utilities.SummaryStatisticsBase.RawCount">
            <summary>
            The running (unweighted) count of elements added to this object.
            </summary>
        </member>
        <member name="P:Microsoft.ML.Internal.Utilities.SummaryStatisticsBase.Count">
            <summary>
            The running (weighted) count of elements.
            </summary>
        </member>
        <member name="P:Microsoft.ML.Internal.Utilities.SummaryStatisticsBase.NonzeroCount">
            <summary>
            The running count of non-zero elements.
            </summary>
        </member>
        <member name="P:Microsoft.ML.Internal.Utilities.SummaryStatisticsBase.NonzeroWeight">
            <summary>
            The running weight of non-zero elements.
            </summary>
        </member>
        <member name="P:Microsoft.ML.Internal.Utilities.SummaryStatisticsBase.Mean">
            <summary>
            The running arithmetic mean.
            </summary>
        </member>
        <member name="P:Microsoft.ML.Internal.Utilities.SummaryStatisticsBase.SampleVariance">
            <summary>
            Thes sample variance.
            </summary>
        </member>
        <member name="P:Microsoft.ML.Internal.Utilities.SummaryStatisticsBase.SampleStdDev">
            <summary>
             The sample standard deviation.
            </summary>
        </member>
        <member name="P:Microsoft.ML.Internal.Utilities.SummaryStatisticsBase.StandardErrorMean">
            <summary>
            Returns the standard error of the mean.
            </summary>
        </member>
        <member name="P:Microsoft.ML.Internal.Utilities.SummaryStatisticsBase.Max">
            <summary>
            The maximum.
            </summary>
        </member>
        <member name="P:Microsoft.ML.Internal.Utilities.SummaryStatisticsBase.Min">
            <summary>
            The minimum.
            </summary>
        </member>
        <member name="M:Microsoft.ML.Internal.Utilities.SummaryStatisticsBase.Add(System.Double,System.Double,System.Int64)">
            <summary>
            Accumulates one more value, optionally weighted.
            This accumulation procedure is based on the following,
            with adjustments as appropriate for weighted instances:
            https://en.wikipedia.org/wiki/Algorithms_for_calculating_variance
            </summary>
            <param name="v">The value</param>
            <param name="w">The weight given to this value</param>
            <param name="c">Amount of appereance of this value</param>
        </member>
        <member name="M:Microsoft.ML.Internal.Utilities.SummaryStatisticsBase.Add(Microsoft.ML.Internal.Utilities.SummaryStatisticsBase)">
            <summary>
            Adds a stats object with another type of stats object. The result
            should be equivalent, up to the effects of numerical imprecision,
            as if in addition to all the values this object has seen, it has
            also seen the values added to the other object.
            </summary>
            <param name="s"></param>
        </member>
        <member name="M:Microsoft.ML.Internal.Utilities.SummaryStatisticsUpToSecondOrderMoments.op_Addition(Microsoft.ML.Internal.Utilities.SummaryStatisticsUpToSecondOrderMoments,Microsoft.ML.Internal.Utilities.SummaryStatisticsUpToSecondOrderMoments)">
            <summary>
            A convenient way to combine the observations of two Stats objects
            into a new Stats object.
            </summary>
            <param name="a">The first operand</param>
            <param name="b">The second operand</param>
            <returns></returns>
        </member>
        <member name="T:Microsoft.ML.Internal.Utilities.SummaryStatistics">
            <summary>
            A class for one-pass accumulation of weighted summary statistics, up
            to the fourth moment. The accumulative algorithms used here may be
            reviewed at
            https://en.wikipedia.org/wiki/Algorithms_for_calculating_variance
            All quantities are weighted, except for <c>RawCount</c>.
            </summary>
        </member>
        <member name="P:Microsoft.ML.Internal.Utilities.SummaryStatistics.Nonzero">
            <summary>
            The running count of non-zero elements.
            </summary>
        </member>
        <member name="P:Microsoft.ML.Internal.Utilities.SummaryStatistics.Skewness">
            <summary>
            The sample skewness.
            </summary>
        </member>
        <member name="P:Microsoft.ML.Internal.Utilities.SummaryStatistics.Kurtosis">
            <summary>
            The sample kurtosis.
            </summary>
        </member>
        <member name="P:Microsoft.ML.Internal.Utilities.SummaryStatistics.SkewnessZ">
            <summary>
            Z-test value for a normality test based on the skew.
            Under the null hypothesis of normality this quantity will
            itself be approximately normally distributed.
            </summary>
        </member>
        <member name="P:Microsoft.ML.Internal.Utilities.SummaryStatistics.KurtosisZ">
            <summary>
            Z-test value for a normality test based on the kurtosis.
            Under the null hypothesis of normality this quantity will
            itself be approximately normally distributed.
            </summary>
        </member>
        <member name="P:Microsoft.ML.Internal.Utilities.SummaryStatistics.OmnibusK2">
             <summary>
             Omnibus K2 unifying the skew and kurtosis Z-tests. Under the
             null hypothesis of normality this quantity will be approximately
             chi-squared distributed.
            
             D'Agostino, Ralph B.; Albert Belanger; Ralph B. D'Agostino, Jr (1990). "A suggestion
             for using powerful and informative tests of normality". The American Statistician 44
             (4): 316–321. JSTOR 2684359.
             </summary>
        </member>
        <member name="M:Microsoft.ML.Internal.Utilities.SummaryStatistics.Add(System.Double,System.Double,System.Int64)">
            <summary>
            Accumulates one more value, optionally weighted.
            This accumulation procedure is based on the following,
            with adjustments as appropriate for weighted instances:
            https://en.wikipedia.org/wiki/Algorithms_for_calculating_variance
            </summary>
            <param name="v">The value</param>
            <param name="w">The weight given to this value</param>
            <param name="c">Amount of appereance of this value</param>
        </member>
        <member name="M:Microsoft.ML.Internal.Utilities.SummaryStatistics.Add(Microsoft.ML.Internal.Utilities.SummaryStatistics)">
            <summary>
            Adds a stats object with another type of stats object. The result
            should be equivalent, up to the effects of numerical imprecision,
            as if in addition to all the values this object has seen, it has
            also seen the values added to the other object.
            </summary>
            <param name="s"></param>
        </member>
        <member name="M:Microsoft.ML.Internal.Utilities.SummaryStatistics.op_Addition(Microsoft.ML.Internal.Utilities.SummaryStatistics,Microsoft.ML.Internal.Utilities.SummaryStatistics)">
            <summary>
            A convenient way to combine the observations of two Stats objects
            into a new Stats object.
            </summary>
            <param name="a">The first operand</param>
            <param name="b">The second operand</param>
            <returns></returns>
        </member>
        <member name="T:Microsoft.ML.Internal.Utilities.SupervisedBinFinder">
             <summary>
             This class performs discretization of (value, label) pairs into bins in a way that minimizes
             the target function "minimum description length".
             The algorithm is outlineed in an article
             "Multi-Interval Discretization of Continuous-Valued Attributes for Classification Learning"
             [Fayyad, Usama M.; Irani, Keki B. (1993)] https://ijcai.org/Past%20Proceedings/IJCAI-93-VOL2/PDF/022.pdf
            
             The class can be used several times sequentially, it is stateful and not thread-safe.
             Both Single and Double precision processing is implemented, and is identical.
             </summary>
        </member>
        <member name="M:Microsoft.ML.Internal.Utilities.SupervisedBinFinder.FindBins(System.Int32,System.Int32,System.Int32,System.Collections.Generic.IList{System.Single},System.Collections.Generic.IList{System.Int32})">
            <summary>
            Finds the bins for Single values (and integer labels)
            </summary>
            <param name="maxBins">Maximum number of bins</param>
            <param name="minBinSize">Minimum number of values per bin (stopping condition for greedy bin splitting)</param>
            <param name="nLabels">Cardinality of the labels</param>
            <param name="values">The feature values</param>
            <param name="labels">The corresponding label values</param>
            <returns>An array of split points, no more than <paramref name="maxBins"/> total (but maybe less), ending with PositiveInfinity</returns>
        </member>
        <member name="M:Microsoft.ML.Internal.Utilities.SupervisedBinFinder.FindBins(System.Int32,System.Int32,System.Int32,System.Collections.Generic.IList{System.Double},System.Collections.Generic.IList{System.Int32})">
            <summary>
            Finds the bins for Double values (and integer labels)
            </summary>
            <param name="maxBins">Maximum number of bins</param>
            <param name="minBinSize">Minimum number of values per bin (stopping condition for greedy bin splitting)</param>
            <param name="nLabels">Cardinality of the labels</param>
            <param name="values">The feature values</param>
            <param name="labels">The corresponding label values</param>
            <returns>An array of split points, no more than <paramref name="maxBins"/> total (but maybe less), ending with PositiveInfinity</returns>
        </member>
        <member name="M:Microsoft.ML.Internal.Utilities.SupervisedBinFinder.GetEntropy(System.Int32,System.Int32,System.Int32@)">
            <summary>
            Calculate the entropy and label cardinality for a given interval within the data
            </summary>
        </member>
        <member name="M:Microsoft.ML.Internal.Utilities.SupervisedBinFinder.FindBinsCore">
            <summary>
            Finds the optimum bins with respect to <see cref="F:Microsoft.ML.Internal.Utilities.SupervisedBinFinder._cumulativeCounts"/>
            </summary>
            <returns>The sorted array of indices that are exclusive upper bounds of the respective bins</returns>
        </member>
        <member name="T:Microsoft.ML.Internal.Utilities.TextReaderStream">
            <summary>
            A readable <see cref="T:System.IO.Stream"/> that is backed by a <see cref="T:System.IO.TextReader"/>.
            Because text readers strip line breaks from the end of their lines, this
            compensates by inserting <c>\n</c> line feed characters at the end of every
            input line, including the last one.
            </summary>
        </member>
        <member name="M:Microsoft.ML.Internal.Utilities.TextReaderStream.#ctor(System.IO.TextReader)">
            <summary>
            Create a stream wrapping the given text reader, using the <see cref="P:System.Text.Encoding.UTF8"/>
            encoding.
            </summary>
            <param name="baseReader">the reader to wrap</param>
        </member>
        <member name="M:Microsoft.ML.Internal.Utilities.TextReaderStream.#ctor(System.IO.TextReader,System.Text.Encoding)">
            <summary>
            Create a stream wrapping the given text reader, using the given encoding. The class
            assumes that the encoding is distributive, that is, the concatenation of the byte
            encodings of different strings, is a valid byte encoding of the single encoding of
            the concatenation of those strings. (I believe all standard encodings obey this
            property.)
            </summary>
            <param name="baseReader">The reader to wrap.</param>
            <param name="encoding">The encoding to use.</param>
        </member>
        <member name="M:Microsoft.ML.Internal.Utilities.TextReaderStream.EnsureBytes">
            <summary>
            A helper method that will either ensure that <see cref="F:Microsoft.ML.Internal.Utilities.TextReaderStream._buffCur"/> is less
            than <see cref="F:Microsoft.ML.Internal.Utilities.TextReaderStream._buffLim"/> (so there are at least some characters), or that
            <see cref="F:Microsoft.ML.Internal.Utilities.TextReaderStream._eof"/> is set.
            </summary>
        </member>
        <member name="T:Microsoft.ML.Internal.Utilities.ExceptionMarshaller">
            <summary>
            An object that serves as a source of a cancellation token, as well as having the ability
            for anything to push an exception into the message, to trigger the cancellation. The general
            intended usage is that, prior to creating a bunch of collaborating thread workers, this
            object is created and made accessible to them, somehow. Each thread worker will work as they
            would be engineered without this class, except they will wrap their contents in a try-catch
            block to push any exceptions (hopefully none) into this marshaller, using <see cref="M:Microsoft.ML.Internal.Utilities.ExceptionMarshaller.Set(System.String,System.Exception)"/>.
            Further, any potentially blocking operation of the thread workers must be changed to use
            <see cref="P:Microsoft.ML.Internal.Utilities.ExceptionMarshaller.Token"/> as the cancellation token (this token is cancelled iff <see cref="M:Microsoft.ML.Internal.Utilities.ExceptionMarshaller.Set(System.String,System.Exception)"/>
            is ever called). The controlling thread, whatever that may be, once it is either sure
            <see cref="M:Microsoft.ML.Internal.Utilities.ExceptionMarshaller.Set(System.String,System.Exception)"/> has been called (possibly by receiving the cancellation) or is sure somehow
            that the workers have finished by its own means, will call <see cref="M:Microsoft.ML.Internal.Utilities.ExceptionMarshaller.ThrowIfSet(Microsoft.ML.IExceptionContext)"/> to throw
            the set exception as an inner exception, in the wrapping thread.
            </summary>
        </member>
        <member name="P:Microsoft.ML.Internal.Utilities.ExceptionMarshaller.Token">
            <summary>
            A cancellation token, whose source will be cancelled if <see cref="M:Microsoft.ML.Internal.Utilities.ExceptionMarshaller.Set(System.String,System.Exception)"/> is ever called.
            Any thread blocking operation of a family of thread workers using this structure
            must use this cancellation token, or else there is a strong possibility for threads
            to stop responding if an exception is thrown at any point.
            </summary>
        </member>
        <member name="M:Microsoft.ML.Internal.Utilities.ExceptionMarshaller.Set(System.String,System.Exception)">
            <summary>
            Store an exception and set the cancellation token. If this was already
            called, this newly passed in exception is ignored. (Important, since a
            common source of exceptions would be the exceptions relating to the cancellation.)
            </summary>
            <param name="component">The type of worker that threw the exception, used
            in the description of the wrapping exception</param>
            <param name="ex">The exception that will become the inner exception</param>
        </member>
        <member name="M:Microsoft.ML.Internal.Utilities.ExceptionMarshaller.ThrowIfSet(Microsoft.ML.IExceptionContext)">
            <summary>
            If an exception was ever set through <see cref="M:Microsoft.ML.Internal.Utilities.ExceptionMarshaller.Set(System.String,System.Exception)"/>, raise it as an appropriate
            inner exception. This should only be called just prior to dispose, when the workers
            have already finished. If there is no stored exception, this will do nothing. Note
            that this does not "expire" the exception, that is, if you were to call this again,
            it would throw the same exception.
            </summary>
        </member>
        <member name="T:Microsoft.ML.Internal.Utilities.Tree`2">
            <summary>
            The tree structure is simultaneously a tree, and a node in a tree. The interface to
            get children occurs through the tree itself implementing itself as a dictionary. This
            tree is not terribly efficient, and is meant to be accomodate additions, deletions,
            and change of values. Because it is implemented as a dictionary, there is an unfortunate
            collision in naming between the dictionary type of "values" (which in this case are
            child trees) and the tree type of values, called "node values."
            </summary>
            <typeparam name="TKey">Children are keyed with values of this type</typeparam>
            <typeparam name="TValue">The type of the node value</typeparam>
        </member>
        <member name="P:Microsoft.ML.Internal.Utilities.Tree`2.NodeValue">
            <summary>
            Either the node value, or the default of the value type,
            if <see cref="P:Microsoft.ML.Internal.Utilities.Tree`2.HasNodeValue"/> is false.
            </summary>
        </member>
        <member name="P:Microsoft.ML.Internal.Utilities.Tree`2.Key">
            <summary>
            This is the key for this child node in its parent, if any. If this is not
            a child of any parent, that is, it is the root of its own tree, then
            </summary>
        </member>
        <member name="P:Microsoft.ML.Internal.Utilities.Tree`2.Parent">
            <summary>
            The parent for this tree, or <c>null</c> if it has no parent.
            </summary>
        </member>
        <member name="P:Microsoft.ML.Internal.Utilities.Tree`2.Keys">
            <summary>
            All child keys for this node.
            </summary>
        </member>
        <member name="P:Microsoft.ML.Internal.Utilities.Tree`2.Values">
            <summary>
            All children for this node.
            </summary>
        </member>
        <member name="P:Microsoft.ML.Internal.Utilities.Tree`2.Count">
            <summary>
            The number of children with this node as a parent.
            </summary>
        </member>
        <member name="M:Microsoft.ML.Internal.Utilities.Tree`2.#ctor">
            <summary>
            Initializes a tree with no node value, and no children.
            </summary>
        </member>
        <member name="M:Microsoft.ML.Internal.Utilities.Tree`2.TryGetValue(`0,Microsoft.ML.Internal.Utilities.Tree{`0,`1}@)">
            <summary>
            Tries to get the subtree for a child key.
            </summary>
            <param name="key">The key of the child to find</param>
            <param name="value">The child, if any, or <c>null</c> if no child
            with this key is present</param>
            <returns>Whether a child with this key was present</returns>
        </member>
        <member name="M:Microsoft.ML.Internal.Utilities.Tree`2.ContainsKey(`0)">
            <summary>
            Sees whether a child with a given key is present.
            </summary>
            <param name="key">The key of the child to find</param>
            <returns></returns>
        </member>
        <member name="M:Microsoft.ML.Internal.Utilities.Tree`2.Add(System.Collections.Generic.KeyValuePair{`0,Microsoft.ML.Internal.Utilities.Tree{`0,`1}})">
            <summary>
            Adds a new child to this dictionary.
            </summary>
            <param name="item">The key / child node pair to add</param>
        </member>
        <member name="M:Microsoft.ML.Internal.Utilities.Tree`2.Add(`0,Microsoft.ML.Internal.Utilities.Tree{`0,`1})">
            <summary>
            Adds a node as a child of this node. This will disconnect the
            </summary>
            <param name="key"></param>
            <param name="newChild"></param>
        </member>
        <member name="M:Microsoft.ML.Internal.Utilities.Tree`2.Detach">
            <summary>
            Removes this node and all its descendants from a tree, leading it to
            be the root of its own tree. Following this, <see cref="P:Microsoft.ML.Internal.Utilities.Tree`2.Parent"/> will
            be <c>null</c>, and the previous parent (if any) will no longer have
            this node present as a child.
            </summary>
        </member>
        <member name="M:Microsoft.ML.Internal.Utilities.Tree`2.Remove(`0)">
            <summary>
            Remove a child with a specified key.
            </summary>
            <param name="key">The key of the child to remove</param>
            <returns></returns>
        </member>
        <member name="T:Microsoft.ML.Internal.Utilities.VBufferUtils">
            <summary>
            Convenience utilities for vector operations on <see cref="T:Microsoft.ML.Data.VBuffer`1"/>.
            </summary>
        </member>
        <member name="M:Microsoft.ML.Internal.Utilities.VBufferUtils.Items``1(``0[],System.Int32[],System.Int32,System.Int32,System.Boolean)">
            <summary>
            A helper method that gives us an iterable over the items given the fields from a <see cref="T:Microsoft.ML.Data.VBuffer`1"/>.
            Note that we have this in a separate utility class, rather than in its more natural location of
            <see cref="T:Microsoft.ML.Data.VBuffer`1"/> itself, due to a bug in the C++/CLI compiler. (DevDiv 1097919:
            [C++/CLI] Nested generic types are not correctly imported from metadata). So, if we want to use
            <see cref="T:Microsoft.ML.Data.VBuffer`1"/> in C++/CLI projects, we cannot have a generic struct with a nested class
            that has the outer struct type as a field.
            </summary>
        </member>
        <member name="M:Microsoft.ML.Internal.Utilities.VBufferUtils.ForEachDefined``1(Microsoft.ML.Data.VBuffer{``0}@,System.Action{System.Int32,``0})">
            <summary>
            Applies <paramref name="visitor"/> to every explicitly defined element of the vector,
            in order of index.
            </summary>
        </member>
        <member name="M:Microsoft.ML.Internal.Utilities.VBufferUtils.ForEachBothDefined``1(Microsoft.ML.Data.VBuffer{``0}@,Microsoft.ML.Data.VBuffer{``0}@,System.Action{System.Int32,``0,``0})">
            <summary>
            Applies the <paramref name="visitor "/>to each corresponding pair of elements
            where the item is emplicitly defined in the vector. By explicitly defined,
            we mean that for a given index <c>i</c>, both vectors have an entry in
            <see cref="M:Microsoft.ML.Data.VBuffer`1.GetValues"/> corresponding to that index.
            </summary>
            <param name="a">The first vector</param>
            <param name="b">The second vector</param>
            <param name="visitor">Delegate to apply to each pair of non-zero values.
            This is passed the index, and two values</param>
        </member>
        <member name="M:Microsoft.ML.Internal.Utilities.VBufferUtils.ForEachEitherDefined``1(Microsoft.ML.Data.VBuffer{``0}@,Microsoft.ML.Data.VBuffer{``0}@,System.Action{System.Int32,``0,``0})">
            <summary>
            Applies the ParallelVisitor to each corresponding pair of elements where at least one is non-zero, in order of index.
            </summary>
            <param name="a">a vector</param>
            <param name="b">another vector</param>
            <param name="visitor">Function to apply to each pair of non-zero values - passed the index, and two values</param>
        </member>
        <member name="M:Microsoft.ML.Internal.Utilities.VBufferUtils.Clear``1(Microsoft.ML.Data.VBuffer{``0}@)">
            <summary>
            Sets all values in the vector to the default value for the type, without changing the
            density or index structure of the input array. That is to say, the count of the input
            vector will be the same afterwards as it was before.
            </summary>
        </member>
        <member name="T:Microsoft.ML.Internal.Utilities.VBufferUtils.SlotValueManipulator`1">
            <summary>
            A delegate for functions that can change a value.
            </summary>
            <param name="slot">Index of entry</param>
            <param name="value">Value to change</param>
        </member>
        <member name="T:Microsoft.ML.Internal.Utilities.VBufferUtils.ValuePredicate`1">
            <summary>
            A predicate on some sort of value.
            </summary>
            <param name="src">The value to test</param>
            <returns>The result of some sort of test from that value</returns>
        </member>
        <member name="M:Microsoft.ML.Internal.Utilities.VBufferUtils.Apply``1(Microsoft.ML.Data.VBuffer{``0}@,Microsoft.ML.Internal.Utilities.VBufferUtils.SlotValueManipulator{``0})">
            <summary>
            Applies the <paramref name="manip"/> to every explicitly defined
            element of the vector.
            </summary>
        </member>
        <member name="M:Microsoft.ML.Internal.Utilities.VBufferUtils.ApplyAt``1(Microsoft.ML.Data.VBuffer{``0}@,System.Int32,Microsoft.ML.Internal.Utilities.VBufferUtils.SlotValueManipulator{``0},Microsoft.ML.Internal.Utilities.VBufferUtils.ValuePredicate{``0})">
            <summary>
            Applies some function on a value at a particular slot value, changing that slot value.
            This function will, wherever possible, not change the structure of <paramref name="dst"/>.
            If the vector is sparse, and the corresponding slot is not explicitly represented,
            then this can involve memory copying and possibly memory reallocation on <paramref name="dst"/>.
            However, if the item is explicitly represented, even if the item is set to the default
            value of <typeparamref name="T"/> it will not change the structure of <paramref name="dst"/>,
            in terms of sparsifying a dense array, or dropping indices.
            </summary>
            <param name="dst">The vector to modify</param>
            <param name="slot">The slot of the vector to modify</param>
            <param name="manip">The manipulation function</param>
            <param name="pred">A predicate that returns true if we should skip insertion of a value into
            sparse vector if it was default. If the predicate is null, we insert any non-default.</param>
        </member>
        <member name="M:Microsoft.ML.Internal.Utilities.VBufferUtils.Densify``1(Microsoft.ML.Data.VBuffer{``0}@)">
            <summary>
            Given a vector, turns it into an equivalent dense representation.
            </summary>
        </member>
        <member name="M:Microsoft.ML.Internal.Utilities.VBufferUtils.DensifyFirst``1(Microsoft.ML.Data.VBuffer{``0}@,System.Int32)">
            <summary>
            Given a vector, ensure that the first <paramref name="denseCount"/> slots are explicitly
            represented.
            </summary>
        </member>
        <member name="M:Microsoft.ML.Internal.Utilities.VBufferUtils.CreateMaybeSparseCopy``1(Microsoft.ML.Data.VBuffer{``0}@,Microsoft.ML.Data.VBuffer{``0}@,Microsoft.ML.Data.InPredicate{``0},System.Single)">
            <summary>
            Creates a maybe sparse copy of a VBuffer.
            Whether the created copy is sparse or not is determined by the proportion of non-default entries compared to the sparsity parameter.
            </summary>
        </member>
        <member name="T:Microsoft.ML.Internal.Utilities.VBufferUtils.PairManipulator`2">
            <summary>
            A delegate for functions that access an index and two corresponding
            values, possibly changing one of them.
            </summary>
            <param name="slot">Slot index of the entry.</param>
            <param name="src">Value from first vector.</param>
            <param name="dst">Value from second vector, which may be manipulated.</param>
        </member>
        <member name="T:Microsoft.ML.Internal.Utilities.VBufferUtils.PairManipulatorCopy`2">
            <summary>
            A delegate for functions that access an index and two corresponding
            values, stores the result in another vector.
            </summary>
            <param name="slot">Slot index of the entry.</param>
            <param name="src">Value from first vector.</param>
            <param name="dst">Value from second vector.</param>
            <param name="res">The value to store the result.</param>
        </member>
        <member name="M:Microsoft.ML.Internal.Utilities.VBufferUtils.ApplyWith``2(Microsoft.ML.Data.VBuffer{``0}@,Microsoft.ML.Data.VBuffer{``1}@,Microsoft.ML.Internal.Utilities.VBufferUtils.PairManipulator{``0,``1})">
            <summary>
            Applies the <see cref="T:Microsoft.ML.Internal.Utilities.VBufferUtils.PairManipulator`2"/> to each pair of elements
            where <paramref name="src"/> is defined, in order of index. If there is
            some value at an index in <paramref name="dst"/> that is not defined in
            <paramref name="src"/>, that item remains without any further modification.
            If either of the vectors are dense, the resulting <paramref name="dst"/>
            will be dense. Otherwise, if both are sparse, the output will be sparse iff
            there is any slot that is not explicitly represented in either vector.
            </summary>
            <param name="src">Argument vector, whose elements are only read</param>
            <param name="dst">Argument vector, that could change</param>
            <param name="manip">Function to apply to each pair of elements</param>
        </member>
        <member name="M:Microsoft.ML.Internal.Utilities.VBufferUtils.ApplyWithCopy``2(Microsoft.ML.Data.VBuffer{``0}@,Microsoft.ML.Data.VBuffer{``1}@,Microsoft.ML.Data.VBuffer{``1}@,Microsoft.ML.Internal.Utilities.VBufferUtils.PairManipulatorCopy{``0,``1})">
            <summary>
            Applies the <see cref="T:Microsoft.ML.Internal.Utilities.VBufferUtils.PairManipulator`2"/> to each pair of elements
            where <paramref name="src"/> is defined, in order of index. It stores the result
            in another vector. If there is some value at an index in <paramref name="dst"/>
            that is not defined in <paramref name="src"/>, that slot value is copied to the
            corresponding slot in the result vector without any further modification.
            If either of the vectors are dense, the resulting <paramref name="res"/>
            will be dense. Otherwise, if both are sparse, the output will be sparse iff
            there is any slot that is not explicitly represented in either vector.
            </summary>
            <param name="src">Argument vector, whose elements are only read</param>
            <param name="dst">Argument vector, whose elements are read in most cases. But in some
            cases <paramref name="dst"/> may be densified.</param>
            <param name="res">Result vector</param>
            <param name="manip">Function to apply to each pair of elements</param>
        </member>
        <member name="M:Microsoft.ML.Internal.Utilities.VBufferUtils.ApplyWithEitherDefined``2(Microsoft.ML.Data.VBuffer{``0}@,Microsoft.ML.Data.VBuffer{``1}@,Microsoft.ML.Internal.Utilities.VBufferUtils.PairManipulator{``0,``1})">
            <summary>
            Applies the <see cref="T:Microsoft.ML.Internal.Utilities.VBufferUtils.PairManipulator`2"/> to each pair of elements
            where either <paramref name="src"/> or <paramref name="dst"/>, has an element
            defined at that index. If either of the vectors are dense, the resulting
            <paramref name="dst"/> will be dense. Otherwise, if both are sparse, the output
            will be sparse iff there is any slot that is not explicitly represented in
            either vector.
            </summary>
            <param name="src">Argument vector, whose elements are only read</param>
            <param name="dst">Argument vector, that could change</param>
            <param name="manip">Function to apply to each pair of elements</param>
        </member>
        <member name="M:Microsoft.ML.Internal.Utilities.VBufferUtils.ApplyWithEitherDefinedCopy``2(Microsoft.ML.Data.VBuffer{``0}@,Microsoft.ML.Data.VBuffer{``1}@,Microsoft.ML.Data.VBuffer{``1}@,Microsoft.ML.Internal.Utilities.VBufferUtils.PairManipulatorCopy{``0,``1})">
            <summary>
            Applies the <see cref="T:Microsoft.ML.Internal.Utilities.VBufferUtils.PairManipulator`2"/> to each pair of elements
            where either <paramref name="src"/> or <paramref name="dst"/>, has an element
            defined at that index. It stores the result in another vector <paramref name="res"/>.
            If either of the vectors are dense, the resulting <paramref name="res"/>
            will be dense. Otherwise, if both are sparse, the output will be sparse iff
            there is any slot that is not explicitly represented in either vector.
            </summary>
            <param name="src">Argument vector, whose elements are only read</param>
            <param name="dst">Argument vector, whose elements are read in most cases. But in some
            cases <paramref name="dst"/> may be densified.</param>
            <param name="res">Result vector</param>
            <param name="manip">Function to apply to each pair of elements</param>
        </member>
        <member name="M:Microsoft.ML.Internal.Utilities.VBufferUtils.ApplyWithCore``2(Microsoft.ML.Data.VBuffer{``0}@,Microsoft.ML.Data.VBuffer{``1}@,Microsoft.ML.Internal.Utilities.VBufferUtils.PairManipulator{``0,``1},System.Boolean)">
            <summary>
            The actual implementation of <see cref="M:Microsoft.ML.Internal.Utilities.VBufferUtils.ApplyWith``2(Microsoft.ML.Data.VBuffer{``0}@,Microsoft.ML.Data.VBuffer{``1}@,Microsoft.ML.Internal.Utilities.VBufferUtils.PairManipulator{``0,``1})"/> and
            <see cref="M:Microsoft.ML.Internal.Utilities.VBufferUtils.ApplyWithEitherDefined``2(Microsoft.ML.Data.VBuffer{``0}@,Microsoft.ML.Data.VBuffer{``1}@,Microsoft.ML.Internal.Utilities.VBufferUtils.PairManipulator{``0,``1})"/>, that has internal branches on the implementation
            where necessary depending on whether this is an inner or outer join of the
            indices of <paramref name="src"/> on <paramref name="dst"/>.
            </summary>
        </member>
        <member name="M:Microsoft.ML.Internal.Utilities.VBufferUtils.ApplyWithCoreCopy``2(Microsoft.ML.Data.VBuffer{``0}@,Microsoft.ML.Data.VBuffer{``1}@,Microsoft.ML.Data.VBuffer{``1}@,Microsoft.ML.Internal.Utilities.VBufferUtils.PairManipulatorCopy{``0,``1},System.Boolean)">
            <summary>
            The actual implementation of <see cref="M:Microsoft.ML.Internal.Utilities.VBufferUtils.ApplyWithCopy``2(Microsoft.ML.Data.VBuffer{``0}@,Microsoft.ML.Data.VBuffer{``1}@,Microsoft.ML.Data.VBuffer{``1}@,Microsoft.ML.Internal.Utilities.VBufferUtils.PairManipulatorCopy{``0,``1})"/> and
            <see cref="M:Microsoft.ML.Internal.Utilities.VBufferUtils.ApplyWithEitherDefinedCopy``2(Microsoft.ML.Data.VBuffer{``0}@,Microsoft.ML.Data.VBuffer{``1}@,Microsoft.ML.Data.VBuffer{``1}@,Microsoft.ML.Internal.Utilities.VBufferUtils.PairManipulatorCopy{``0,``1})"/>, that has internal branches on the implementation
            where necessary depending on whether this is an inner or outer join of the
            indices of <paramref name="src"/> on <paramref name="dst"/>.
            </summary>
        </member>
        <member name="M:Microsoft.ML.Internal.Utilities.VBufferUtils.ApplyIntoEitherDefined``2(Microsoft.ML.Data.VBuffer{``0}@,Microsoft.ML.Data.VBuffer{``1}@,System.Func{System.Int32,``0,``1})">
            <summary>
            Applies a function to explicitly defined elements in a vector <paramref name="src"/>,
            storing the result in <paramref name="dst"/>, overwriting any of its existing contents.
            The contents of <paramref name="dst"/> do not affect calculation. If you instead wish
            to calculate a function that reads and writes <paramref name="dst"/>, see
            <see cref="M:Microsoft.ML.Internal.Utilities.VBufferUtils.ApplyWith``2(Microsoft.ML.Data.VBuffer{``0}@,Microsoft.ML.Data.VBuffer{``1}@,Microsoft.ML.Internal.Utilities.VBufferUtils.PairManipulator{``0,``1})"/> and <see cref="M:Microsoft.ML.Internal.Utilities.VBufferUtils.ApplyWithEitherDefined``2(Microsoft.ML.Data.VBuffer{``0}@,Microsoft.ML.Data.VBuffer{``1}@,Microsoft.ML.Internal.Utilities.VBufferUtils.PairManipulator{``0,``1})"/>. Post-operation,
            <paramref name="dst"/> will be dense iff <paramref name="src"/> is dense.
            </summary>
            <seealso cref="M:Microsoft.ML.Internal.Utilities.VBufferUtils.ApplyWith``2(Microsoft.ML.Data.VBuffer{``0}@,Microsoft.ML.Data.VBuffer{``1}@,Microsoft.ML.Internal.Utilities.VBufferUtils.PairManipulator{``0,``1})"/>
            <seealso cref="M:Microsoft.ML.Internal.Utilities.VBufferUtils.ApplyWithEitherDefined``2(Microsoft.ML.Data.VBuffer{``0}@,Microsoft.ML.Data.VBuffer{``1}@,Microsoft.ML.Internal.Utilities.VBufferUtils.PairManipulator{``0,``1})"/>
        </member>
        <member name="M:Microsoft.ML.Internal.Utilities.VBufferUtils.ApplyInto``3(Microsoft.ML.Data.VBuffer{``0}@,Microsoft.ML.Data.VBuffer{``1}@,Microsoft.ML.Data.VBuffer{``2}@,System.Func{System.Int32,``0,``1,``2})">
            <summary>
            Applies a function <paramref name="func"/> to two vectors, storing the result in
            <paramref name="dst"/>, whose existing contents are discarded and overwritten. The
            function is called for every index value that appears in either <paramref name="a"/>
            or <paramref name="b"/>. If either of the two inputs is dense, the output will
            necessarily be dense. Otherwise, if both are sparse, the output will be sparse iff
            there is any slot that is not explicitly represented in either vector.
            </summary>
        </member>
        <member name="M:Microsoft.ML.Internal.Utilities.VBufferUtils.Copy``1(System.Collections.Generic.List{``0},Microsoft.ML.Data.VBuffer{``0}@,System.Int32)">
            <summary>
            Copy from a source list to the given VBuffer destination.
            </summary>
        </member>
        <member name="M:Microsoft.ML.Internal.Utilities.VBufferUtils.Resize``1(Microsoft.ML.Data.VBuffer{``0}@,System.Int32,System.Nullable{System.Int32})">
            <summary>
            Updates the logical length and number of physical values to be represented in
            <paramref name="dst"/>, while preserving the underlying buffers.
            </summary>
        </member>
        <member name="T:Microsoft.ML.IExceptionContext">
            <summary>
            Interface for "processing" exceptions before they are thrown. This can
            be used to add context to the exception, wrap the exception in another one,
            totally replace the exception, etc. It is not legal to return null from
            Process (unless null was passed in, which really shouldn't happen).
            </summary>
        </member>
        <member name="P:Microsoft.ML.IExceptionContext.ContextDescription">
            <summary>
            A string describing the context itself.
            </summary>
        </member>
        <member name="M:Microsoft.ML.Contracts.Process``1(``0,Microsoft.ML.IExceptionContext)">
            <summary>
            Does standard processing of an exception (typically called after construction
            but before it is thrown).
            </summary>
        </member>
        <member name="M:Microsoft.ML.Contracts.Mark``1(``0)">
            <summary>
            Mark the exception by setting <see cref="F:Microsoft.ML.Contracts.IsMarkedKey"/> in the exception
            <see cref="P:System.Exception.Data"/> to 1.
            </summary>
        </member>
        <member name="M:Microsoft.ML.Contracts.IsMarked(System.Exception)">
            <summary>
            Indicates whether the exception was "marked" the Contracts code.
            </summary>
        </member>
        <member name="M:Microsoft.ML.Contracts.MarkSensitive``1(``0,Microsoft.ML.MessageSensitivity)">
            <summary>
            Exceptions whose message communicates potentially sensitive information should be
            marked using this method, before they are thrown. Note that if the exception already
            had this flag set, the message will be flagged with the bitwise or of the existing
            flag, alongside the passed in sensivity.
            </summary>
        </member>
        <member name="M:Microsoft.ML.Contracts.Sensitivity(System.Exception)">
            <summary>
            This is a convenience method to get the sensitivity of an exception,
            as encoded with <see cref="F:Microsoft.ML.Contracts.SensitivityKey"/>. If there is no key, then
            the message is assumed to be of unknown sensitivity, i.e., it is assumed
            that it might contain literally anything.
            </summary>
            <param name="ex">The exception to query</param>
            <returns>The value encoded at the <see cref="F:Microsoft.ML.Contracts.SensitivityKey"/>, if it is
            a <see cref="T:Microsoft.ML.MessageSensitivity"/> value. If neither of these conditions
            hold then <see cref="F:Microsoft.ML.MessageSensitivity.Unknown"/> is returned.</returns>
        </member>
        <member name="T:Microsoft.ML.Contracts.SensitiveExceptionContext">
            <summary>
            This is an internal convenience implementation of an exception context to make marking
            exceptions with a specific sensitivity flag a bit less onorous. The alternative to a scheme
            like this, where messages are marked through use of <see cref="M:Microsoft.ML.Contracts.SensitiveExceptionContext.Process``1(``0)"/>,
            would be that every check and exception method in this file would need some "peer" where
            sensitivity was set. Since there are so many, we have this method instead. I'm not sure if
            there will be performance implications. There shouldn't be, since checks rarely happen in
            tight loops.
            </summary>
        </member>
        <member name="F:Microsoft.ML.Contracts.SensitiveExceptionContext.Inner">
            <summary>
            We will run this instances <see cref="M:Microsoft.ML.IExceptionContext.Process``1(``0)"/> first.
            This can be null.
            </summary>
        </member>
        <member name="F:Microsoft.ML.Contracts.SensitiveExceptionContext.ToMark">
            <summary>
            Exceptions will be marked with this. If <see cref="F:Microsoft.ML.Contracts.SensitiveExceptionContext.Inner"/> happens to mark it with a sensivity
            flag, then the result will not only be this value, but the bitwise or of this with the existing
            value.
            </summary>
        </member>
        <member name="M:Microsoft.ML.Contracts.NotSensitive">
            <summary>
            A convenience context for marking exceptions from checks and excepts with <see cref="F:Microsoft.ML.MessageSensitivity.None"/>.
            </summary>
        </member>
        <member name="M:Microsoft.ML.Contracts.NotSensitive(Microsoft.ML.IExceptionContext)">
            <summary>
            A convenience context for marking exceptions from checks and excepts with <see cref="F:Microsoft.ML.MessageSensitivity.None"/>.
            </summary>
        </member>
        <member name="M:Microsoft.ML.Contracts.UserSensitive">
            <summary>
            A convenience context for marking exceptions from checks and excepts with <see cref="F:Microsoft.ML.MessageSensitivity.UserData"/>.
            </summary>
        </member>
        <member name="M:Microsoft.ML.Contracts.UserSensitive(Microsoft.ML.IExceptionContext)">
            <summary>
            A convenience context for marking exceptions from checks and excepts with <see cref="F:Microsoft.ML.MessageSensitivity.UserData"/>.
            </summary>
        </member>
        <member name="M:Microsoft.ML.Contracts.SchemaSensitive">
            <summary>
            A convenience context for marking exceptions from checks and excepts with <see cref="F:Microsoft.ML.MessageSensitivity.Schema"/>.
            </summary>
        </member>
        <member name="M:Microsoft.ML.Contracts.SchemaSensitive(Microsoft.ML.IExceptionContext)">
            <summary>
            A convenience context for marking exceptions from checks and excepts with <see cref="F:Microsoft.ML.MessageSensitivity.Schema"/>.
            </summary>
        </member>
        <member name="M:Microsoft.ML.Contracts.SetAssertHandler(System.Action{System.String,Microsoft.ML.IExceptionContext})">
            <summary>
            Sets the assert handler to the given function, returning the previous handler.
            </summary>
        </member>
        <member name="M:Microsoft.ML.Contracts.Except">
            <summary>
            Default exception type (currently InvalidOperationException)
            </summary>
        </member>
        <member name="M:Microsoft.ML.Contracts.ExceptUserArg(System.String)">
            <summary>
            For signalling bad user input.
            </summary>
        </member>
        <member name="M:Microsoft.ML.Contracts.ExceptParam(System.String)">
            <summary>
            For signalling bad function parameters.
            </summary>
        </member>
        <member name="M:Microsoft.ML.Contracts.ExceptValue(System.String)">
            <summary>
            For signalling null function parameters.
            </summary>
        </member>
        <member name="M:Microsoft.ML.Contracts.ExceptEmpty(System.String)">
            <summary>
            For signalling null or empty function parameters (strings, arrays, collections, etc).
            </summary>
        </member>
        <member name="M:Microsoft.ML.Contracts.ExceptWhiteSpace(System.String)">
            <summary>
            For signalling null, empty or white-space function parameters (strings, arrays, collections, etc).
            </summary>
        </member>
        <member name="M:Microsoft.ML.Contracts.ExceptDecode">
            <summary>
            For signalling errors in decoding information, whether while reading from a file,
            parsing user input, etc.
            </summary>
            <returns></returns>
        </member>
        <member name="M:Microsoft.ML.Contracts.ExceptIO">
            <summary>
            For signalling IO failures.
            </summary>
        </member>
        <member name="M:Microsoft.ML.Contracts.ExceptNotImpl">
            <summary>
            For signalling functionality that is not YET implemented.
            </summary>
        </member>
        <member name="M:Microsoft.ML.Contracts.ExceptNotSupp">
            <summary>
            For signalling functionality that is not implemented by design.
            </summary>
        </member>
        <member name="M:Microsoft.ML.Contracts.ExceptSchemaMismatch(System.String,System.String,System.String)">
            <summary>
            For signalling schema validation issues.
            </summary>
        </member>
        <member name="M:Microsoft.ML.Contracts.CheckUserArg(System.Boolean,System.String)">
            <summary>
            CheckUserArg / ExceptUserArg should be used when the validation of user-provided arguments failed.
            Typically, this is shortly after the arguments are parsed using CmdParser.
            </summary>
        </member>
        <member name="M:Microsoft.ML.Contracts.CheckAlive(Microsoft.ML.IHostEnvironment)">
            <summary>
            Check state of the host and throw exception if host marked to stop all exection.
            </summary>
        </member>
        <member name="M:Microsoft.ML.Contracts.CheckValueOrNull``1(``0)">
            <summary>
            This documents that the parameter can legally be null.
            </summary>
        </member>
        <member name="M:Microsoft.ML.Contracts.CheckValueOrNull``1(Microsoft.ML.IExceptionContext,``0)">
            <summary>
            This documents that the parameter can legally be null.
            </summary>
        </member>
        <member name="M:Microsoft.ML.Contracts.AssertValueOrNull``1(``0)">
            <summary>
            This documents that the parameter can legally be null.
            </summary>
        </member>
        <member name="T:Microsoft.ML.TauswortheHybrid">
            <summary>
            Tausworthe hybrid random number generator.
            </summary>
        </member>
    </members>
</doc>