コード例 #1
0
ファイル: Parallel.cs プロジェクト: netmatze/ParallelLib
        /// <summary>
        /// Eine for schleife wird parallel auf mehreren Kernen ausgeführt. Zusätzlich wird eine Aggregation auf die einzelnen Ergebnisse
        /// des Schleifenbodys angewendet.
        /// </summary>
        /// <typeparam name="TState">type des state Objekts</typeparam>
        /// <typeparam name="T">type der mitübergebenen value</typeparam>
        /// <param name="from">von welchem Wert an soll die Schleife laufen</param>
        /// <param name="to">bis zu welchen Wert soll die for Schleife laufen</param>
        /// <param name="state">initalisierung des local States</param>
        /// <param name="action">Der Schleifenkörper der ausgeführt wird.
        /// (mit dem übergebenen Wert kann auf die Schleifenvariable zugegriffen werden)</param>
        /// <param name="aggregation">Die Aggregation die auf die Teilergebnisse der einzelnen Schleifenbodies ausgeführt werden</param>
        /// <param name="value">mitübergebene value</param>
        public static void For <T, TState>(int from, int to, Func <T, TState> state,
                                           Action <T, ThreadLocalState <TState> > action, InvokeAction <T, ThreadLocalState <TState> > aggregation, T value)
        {
            For forExecution = new For();

            forExecution.ForExecution <TState, T>(from, to, 1, state, action, aggregation, value);
        }
コード例 #2
0
ファイル: Parallel.cs プロジェクト: netmatze/ParallelLib
        /// <summary>
        /// Eine for Schleife wird parallel auf mehreren Kernen ausgeführt.
        /// </summary>
        /// <typeparam name="T1">Type des ersten value Elements.</typeparam>
        /// <typeparam name="T2">Type des zweiten value Elements.</typeparam>
        /// <param name="from">von welchem Wert an soll die Schleife laufen</param>
        /// <param name="to">bis zu welchen Wert soll die for Schleife laufen</param>
        /// <param name="step">um wieviel soll die Schleifenvaribale bei jedem Durchlauf erhöht werden</param>
        /// <param name="action">Der Schleifenkörper der ausgeführt wird.
        /// (mit dem übergebenen Wert kann auf die Schleifenvariable zugegriffen werden)</param>
        /// <param name="executionConstancy">worksteeling verwenden (Nonconstant)</param>
        /// <param name="value1">erster mitübergebener wert</param>
        /// <param name="value2">zweiter mitübergebener wert</param>
        public static void For <T1, T2>(int from, int to, int step, Action <T1, T2> action, ExecutionConstancyEnum executionConstancy, T1 value1, T2 value2)
        {
            For forExecution = new For();

            forExecution.ForExecution <T1, T2>(from, to, step, action, executionConstancy, value1, value2);
        }
コード例 #3
0
ファイル: Parallel.cs プロジェクト: netmatze/ParallelLib
        /// <summary>
        /// Eine for Schleife wird parallel auf mehreren Kernen ausgeführt.
        /// </summary>
        /// <typeparam name="T">Type des value Elements.</typeparam>
        /// <param name="from">von welchem Wert an soll die Schleife laufen.</param>
        /// <param name="to">bis zu welchen Wert soll die for Schleife laufen.</param>
        /// <param name="step">um wieviel soll die Schleifenvaribale bei jedem Durchlauf erhöht werden.</param>
        /// <param name="action">Der Schleifenkörper der ausgeführt wird.
        /// (mit dem übergebenen Wert kann auf die Schleifenvariable zugegriffen werden)</param>
        /// <param name="value1">mitübergebener wert</param>
        public static void For <T>(int from, int to, int step, Action <T> action, T value)
        {
            For forExecution = new For();

            forExecution.ForExecution <T>(from, to, step, action, value);
        }
コード例 #4
0
ファイル: Parallel.cs プロジェクト: netmatze/ParallelLib
        /// <summary>
        /// Eine for schleife wird parallel auf mehreren Kernen ausgeführt.
        /// </summary>
        /// <param name="from">von welchem Wert an soll die Schleife laufen</param>
        /// <param name="to">bis zu welchen Wert soll die for Schleife laufen</param>
        /// <param name="step">um wieviel soll die Schleifenvaribale bei jedem Durchlauf erhöht werden</param>
        /// <param name="action">Der Schleifenkörper der ausgeführt wird.
        /// (mit dem übergebenen Wert kann auf die Schleifenvariable zugegriffen werden)</param>
        /// <param name="executionConstancy">worksteeling verwenden (Nonconstant)</param>
        public static void For(int from, int to, int step, Action action, ExecutionConstancyEnum executionConstancy)
        {
            For forExecution = new For();

            forExecution.ForExecution(from, to, step, action, executionConstancy);
        }
コード例 #5
0
ファイル: Parallel.cs プロジェクト: netmatze/ParallelLib
        /// <summary>
        /// Eine for Schleife wird parallel auf mehreren Kernen ausgeführt.
        /// </summary>
        /// <param name="from">von welchem Wert an soll die Schleife laufen</param>
        /// <param name="to">bis zu welchen Wert soll die for Schleife laufen</param>
        /// <param name="step">um wieviel soll die Schleifenvaribale bei jedem Durchlauf erhöht werden</param>
        /// <param name="action">Der Schleifenkörper der ausgeführt wird.
        /// (mit dem übergebenen Wert kann auf die Schleifenvariable zugegriffen werden)</param>
        public static void For(int from, int to, int step, Action action)
        {
            For forExecution = new For();

            forExecution.ForExecution(from, to, step, action);
        }
コード例 #6
0
ファイル: Parallel.cs プロジェクト: netmatze/ParallelLib
        /// <summary>
        /// Eine for schleife wird parallel auf mehreren Kernen ausgeführt.
        /// </summary>
        /// <typeparam name="T1">Type des ersten value Elements.</typeparam>
        /// <typeparam name="T2">Type des zweiten value Elements.</typeparam>
        /// <param name="from">von welchem Wert an soll die Schleife laufen</param>
        /// <param name="to">bis zu welchen Wert soll die for Schleife laufen</param>
        /// <param name="action">Der Schleifenkörper der ausgeführt wird.
        /// (mit dem übergebenen Wert kann auf die Schleifenvariable zugegriffen werden)</param>
        /// <param name="value">erstes value Element dass an den Schleifenkörper mitgegeben wird.</param>
        /// <param name="value">zweites value Element dass an den Schleifenkörper mitgegeben wird.</param>
        public static void For <T1, T2>(int from, int to, Action <T1, T2> action, T1 value1, T2 value2)
        {
            For forExecution = new For();

            forExecution.ForExecution <T1, T2>(from, to, 1, action, value1, value2);
        }
コード例 #7
0
ファイル: Parallel.cs プロジェクト: netmatze/ParallelLib
        /// <summary>
        /// Eine for schleife wird parallel auf mehreren Kernen ausgeführt.
        /// </summary>
        /// <typeparam name="T">Type des value Elements.</typeparam>
        /// <param name="from">von welchem Wert an soll die Schleife laufen</param>
        /// <param name="to">bis zu welchen Wert soll die for Schleife laufen</param>
        /// <param name="action">Der Schleifenkörper der ausgeführt wird.
        /// (mit dem übergebenen Wert kann auf die Schleifenvariable zugegriffen werden)</param>
        /// <param name="executionConstancy">worksteeling verwenden (Nonconstant)</param>
        /// <param name="value">value Element dass an den Schleifenkörper mitgegeben wird.</param>
        public static void For <T>(int from, int to, Action <T> action, ExecutionConstancyEnum executionConstancy, T value)
        {
            For forExecution = new For();

            forExecution.ForExecution <T>(from, to, 1, action, executionConstancy, value);
        }