/// /// This file is part of ILNumerics Community Edition. /// /// ILNumerics Community Edition - high performance computing for applications. /// Copyright (C) 2006 - 2012 Haymo Kutschbach, http://ilnumerics.net /// /// ILNumerics Community Edition is free software: you can redistribute it and/or modify /// it under the terms of the GNU General Public License version 3 as published by /// the Free Software Foundation. /// /// ILNumerics Community Edition is distributed in the hope that it will be useful, /// but WITHOUT ANY WARRANTY; without even the implied warranty of /// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the /// GNU General Public License for more details. /// /// You should have received a copy of the GNU General Public License /// along with ILNumerics Community Edition. See the file License.txt in the root /// of your distribution package. If not, see . /// /// In addition this software uses the following components and/or licenses: /// /// ================================================================================= /// The Open Toolkit Library License /// /// Copyright (c) 2006 - 2009 the Open Toolkit library. /// /// Permission is hereby granted, free of charge, to any person obtaining a copy /// of this software and associated documentation files (the "Software"), to deal /// in the Software without restriction, including without limitation the rights to /// use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of /// the Software, and to permit persons to whom the Software is furnished to do /// so, subject to the following conditions: /// /// The above copyright notice and this permission notice shall be included in all /// copies or substantial portions of the Software. /// /// ================================================================================= /// using System; using System.Collections.Generic; using System.Text; using System.Runtime.InteropServices; using ILNumerics.Storage; using ILNumerics.Misc; using ILNumerics.Native; using ILNumerics.Exceptions; namespace ILNumerics { public partial class ILMath { /// /// Create new array, fill elements with constant value /// /// Element type /// Constant value for all elements /// Size of new array /// New array according to size with all elements set to 'value' public static ILRetArray array(T value, ILSize size) { T[] newData = ILMemoryPool.Pool.New(size.NumberOfElements); int i = 0, itemLength, itemCount, workerCount = 1; if (Settings.s_maxNumberThreads > 2 && size.NumberOfElements >= ILNumerics.Settings.s_minParallelElement1Count / 2) { if (size.NumberOfElements >= ILNumerics.Settings.s_minParallelElement1Count / Settings.s_maxNumberThreads) { itemCount = Settings.s_maxNumberThreads; itemLength = size.NumberOfElements / Settings.s_maxNumberThreads; } else { itemCount = 2; itemLength = size.NumberOfElements / 2; } } else { itemCount = 1; itemLength = size.NumberOfElements; } Action worker = (data) => { Tuple range = (Tuple)data; int start = range.Item1, endEx = range.Item2; for (int c = start; c < endEx; c++) { newData[c] = value; } System.Threading.Interlocked.Decrement(ref workerCount); }; for (i = 0; i < workerCount - 1; i++) { System.Threading.Interlocked.Increment(ref workerCount); Tuple range = Tuple.Create(i * itemLength, (i + 1) * itemLength); ILThreadPool.QueueUserWorkItem(i, worker, range); } worker(Tuple.Create(i * itemLength, size.NumberOfElements)); System.Threading.SpinWait.SpinUntil(() => { return workerCount <= 0; }); ILRetArray ret = new ILRetArray(newData, size); return ret; } /// /// Create new array, fill element with constant value /// /// Element type /// Constant value for all elements /// Size of new array /// New array according to size with all elements set to 'value' public static ILRetArray array(T value, params int[] size) { return array(value, new ILSize(size)); } /// /// Create array, given elements and size /// /// Element type /// System.Array of predefined elements /// Size of every dimension for the new array, must correspond to the number of elements in . /// Newly created array /// The System.Array given as is taken /// as storage for the new array without copy. Make sure not to reference that /// System.Array directly afterwards. /// In order to prevent for memory leaks on long runnning algorithms, System.Arrays should /// not get created via the 'new' keyword - but fetched from the ILMemoryPool. public static ILRetArray array(T[] elements, params int[] size) { ILSize newDimensions = new ILSize(size); ILRetArray ret = new ILRetArray(elements, newDimensions); return ret; } /// /// Create array, given elements and size /// /// Element type /// System.Array of predefined elements /// Size of the new array, must correspond to the number of elements in . /// Newly created array /// The System.Array given as is taken /// as storage for the new array without copy. Make sure not to reference that /// System.Array directly afterwards. /// In order to prevent for memory leaks on long runnning algorithms, System.Arrays should /// not get created via the 'new' keyword - but fetched from the ILMemoryPool. /// public static ILRetArray array(T[] elements, ILSize size) { ILRetArray ret = new ILRetArray(elements, size); return ret; } /// /// Create array, given elements and size /// /// Element type /// Variable argument list with elements /// Size of the new array, must correspond to the number of elements in . /// Newly created array /// The elements given as are used /// for the new array without copy. For being a reference type, make sure not to reference any /// elements directly afterwards. /// public static ILRetArray array(ILSize size, params T[] elements) { ILRetArray ret = new ILRetArray(elements, size); return ret; } /// /// Create column vector from given elements /// /// Element type /// List of elements /// Newly created vector with elements given /// If an System.Array was given as params argument, the array is directly taken /// as storage for the new array without copy. Make sure not to reference the /// System.Array directly afterwards! /// In order to prevent for memory leaks on long runnning algorithms, System.Arrays should /// not get created via the 'new' keyword - but fetched from the ILMemoryPool. /// The shape of the vector created is controlled by the setting switch . /// This switch defaults to false which will cause the creation of a column vector. /// /// public static ILRetArray array(params T[] elements) { ILSize newDimensions; if (Settings.CreateRowVectorsByDefault) { newDimensions = new ILSize(1, elements.Length); } else { newDimensions = new ILSize(elements.Length, 1); } ILRetArray ret = new ILRetArray(elements, newDimensions); return ret; } /// /// Create row vector /// /// Element type /// Elements of the row vector /// New row vector public static ILRetArray row(params T[] elements) { if (elements == null || elements.Length == 0) { return empty(ILSize.Empty00); } return new ILRetArray(elements, new ILSize(1, elements.Length)); } /// /// Create column vector /// /// Element type /// Elements of the column vector /// New column vector public static ILRetArray column(params T[] elements) { if (elements == null || elements.Length == 0) { return empty(ILSize.Empty00); } return new ILRetArray(elements, new ILSize(elements.Length, 1)); } } }