Free cookie consent management tool by TermsFeed Policy Generator

source: branches/HeuristicLab.Problems.GaussianProcessTuning/ILNumerics.2.14.4735.573/Functions/builtin/convert.cs @ 11316

Last change on this file since 11316 was 9102, checked in by gkronber, 12 years ago

#1967: ILNumerics source for experimentation
File size: 85.8 KB
Line 
1///
2///    This file is part of ILNumerics Community Edition.
3///
4///    ILNumerics Community Edition - high performance computing for applications.
5///    Copyright (C) 2006 - 2012 Haymo Kutschbach, http://ilnumerics.net
6///
7///    ILNumerics Community Edition is free software: you can redistribute it and/or modify
8///    it under the terms of the GNU General Public License version 3 as published by
9///    the Free Software Foundation.
10///
11///    ILNumerics Community Edition is distributed in the hope that it will be useful,
12///    but WITHOUT ANY WARRANTY; without even the implied warranty of
13///    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14///    GNU General Public License for more details.
15///
16///    You should have received a copy of the GNU General Public License
17///    along with ILNumerics Community Edition. See the file License.txt in the root
18///    of your distribution package. If not, see <http://www.gnu.org/licenses/>.
19///
20///    In addition this software uses the following components and/or licenses:
21///
22///    =================================================================================
23///    The Open Toolkit Library License
24///   
25///    Copyright (c) 2006 - 2009 the Open Toolkit library.
26///   
27///    Permission is hereby granted, free of charge, to any person obtaining a copy
28///    of this software and associated documentation files (the "Software"), to deal
29///    in the Software without restriction, including without limitation the rights to
30///    use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of
31///    the Software, and to permit persons to whom the Software is furnished to do
32///    so, subject to the following conditions:
33///
34///    The above copyright notice and this permission notice shall be included in all
35///    copies or substantial portions of the Software.
36///
37///    =================================================================================
38///   
39
40using System;
41using System.Collections.Generic;
42using System.Text;
43using ILNumerics.Storage;
44using ILNumerics.Misc;
45using ILNumerics.Exceptions;
46using System.Runtime.InteropServices;
47using System.Numerics;
48
49
50namespace ILNumerics  {
51    public partial class ILMath {
52        /// <summary>
53        /// Convert a numeric array to another numeric type
54        /// </summary>
55        /// <param name="X">Input array</param>
56        /// <typeparam name="inT">Type of array to convert</typeparam>
57        /// <typeparam name="outT">Type of array to return</typeparam>
58        /// <returns>Converted array</returns>
59        /// <remarks> The newly created array will be converted to the required type.
60        /// <para>The array returned will always use new memory! Even if the type requested
61        /// matches the incoming type.</para></remarks>
62        public static unsafe ILRetArray<outT> convert<inT, outT>(ILInArray<inT> X) {
63            using (ILScope.Enter(X)) {
64                outT[] retArrGen = ILMemoryPool.Pool.New<outT>(X.Size.NumberOfElements);
65                inT[] inArrGen = X.GetArrayForRead();
66                if (inArrGen is double[]) {
67    #region input double
68                    double[] inArr = (double[])(object)inArrGen; 
69                    if (false) {
70
71                    } else if (retArrGen is  double []) {
72             double [] dummyArray = ( double [])(object)retArrGen;
73                        fixed ( double * pretArr = dummyArray)
74                        fixed (double * pinArr = inArr) {
75                            double * pInWalk = pinArr;
76                            double * pInEnd = pinArr + X.S.NumberOfElements;
77                             double * pRetWalk = pretArr;
78                            while (pInWalk < pInEnd) {
79                                *(pRetWalk++) = ( double ) (*(pInWalk++));
80                            }
81                        }
82
83#region HYCALPER AUTO GENERATED CODE
84
85                    } else if (retArrGen is  Int64 []) {
86             Int64 [] dummyArray = ( Int64 [])(object)retArrGen;
87                        fixed ( Int64 * pretArr = dummyArray)
88                        fixed (double * pinArr = inArr) {
89                            double * pInWalk = pinArr;
90                            double * pInEnd = pinArr + X.S.NumberOfElements;
91                            Int64 * pRetWalk = pretArr;
92                            while (pInWalk < pInEnd) {
93                                *(pRetWalk++) = ( Int64 ) (*(pInWalk++));
94                            }
95                        }
96                    } else if (retArrGen is  Int32 []) {
97             Int32 [] dummyArray = ( Int32 [])(object)retArrGen;
98                        fixed ( Int32 * pretArr = dummyArray)
99                        fixed (double * pinArr = inArr) {
100                            double * pInWalk = pinArr;
101                            double * pInEnd = pinArr + X.S.NumberOfElements;
102                            Int32 * pRetWalk = pretArr;
103                            while (pInWalk < pInEnd) {
104                                *(pRetWalk++) = ( Int32 ) (*(pInWalk++));
105                            }
106                        }
107                    } else if (retArrGen is  byte []) {
108             byte [] dummyArray = ( byte [])(object)retArrGen;
109                        fixed ( byte * pretArr = dummyArray)
110                        fixed (double * pinArr = inArr) {
111                            double * pInWalk = pinArr;
112                            double * pInEnd = pinArr + X.S.NumberOfElements;
113                            byte * pRetWalk = pretArr;
114                            while (pInWalk < pInEnd) {
115                                *(pRetWalk++) = ( byte ) (*(pInWalk++));
116                            }
117                        }
118                    } else if (retArrGen is  fcomplex []) {
119             fcomplex [] dummyArray = ( fcomplex [])(object)retArrGen;
120                        fixed ( fcomplex * pretArr = dummyArray)
121                        fixed (double * pinArr = inArr) {
122                            double * pInWalk = pinArr;
123                            double * pInEnd = pinArr + X.S.NumberOfElements;
124                            fcomplex * pRetWalk = pretArr;
125                            while (pInWalk < pInEnd) {
126                                *(pRetWalk++) = ( fcomplex ) (*(pInWalk++));
127                            }
128                        }
129                    } else if (retArrGen is  complex []) {
130             complex [] dummyArray = ( complex [])(object)retArrGen;
131                        fixed ( complex * pretArr = dummyArray)
132                        fixed (double * pinArr = inArr) {
133                            double * pInWalk = pinArr;
134                            double * pInEnd = pinArr + X.S.NumberOfElements;
135                            complex * pRetWalk = pretArr;
136                            while (pInWalk < pInEnd) {
137                                *(pRetWalk++) = ( complex ) (*(pInWalk++));
138                            }
139                        }
140                    } else if (retArrGen is  float []) {
141             float [] dummyArray = ( float [])(object)retArrGen;
142                        fixed ( float * pretArr = dummyArray)
143                        fixed (double * pinArr = inArr) {
144                            double * pInWalk = pinArr;
145                            double * pInEnd = pinArr + X.S.NumberOfElements;
146                            float * pRetWalk = pretArr;
147                            while (pInWalk < pInEnd) {
148                                *(pRetWalk++) = ( float ) (*(pInWalk++));
149                            }
150                        }
151
152#endregion HYCALPER AUTO GENERATED CODE
153                   } else
154                        throw new ILArgumentException("unsupported target type: " + typeof(outT).Name);
155    #endregion
156                } else if (inArrGen is float[]) {
157    #region input float
158                    float[] inArr = (float[])(object)inArrGen; 
159                    if (false) {
160
161                    } else if (retArrGen is  double []) {
162             double [] dummyArray = ( double [])(object)retArrGen;
163                        fixed ( double * pretArr = dummyArray)
164                        fixed (float * pinArr = inArr) {
165                            float * pInWalk = pinArr;
166                            float * pInEnd = pinArr + X.S.NumberOfElements;
167                             double * pRetWalk = pretArr;
168                            while (pInWalk < pInEnd) {
169                                *(pRetWalk++) = ( double ) (*(pInWalk++));
170                            }
171                        }
172
173#region HYCALPER AUTO GENERATED CODE
174
175                    } else if (retArrGen is  Int64 []) {
176             Int64 [] dummyArray = ( Int64 [])(object)retArrGen;
177                        fixed ( Int64 * pretArr = dummyArray)
178                        fixed (float * pinArr = inArr) {
179                            float * pInWalk = pinArr;
180                            float * pInEnd = pinArr + X.S.NumberOfElements;
181                            Int64 * pRetWalk = pretArr;
182                            while (pInWalk < pInEnd) {
183                                *(pRetWalk++) = ( Int64 ) (*(pInWalk++));
184                            }
185                        }
186                    } else if (retArrGen is  Int32 []) {
187             Int32 [] dummyArray = ( Int32 [])(object)retArrGen;
188                        fixed ( Int32 * pretArr = dummyArray)
189                        fixed (float * pinArr = inArr) {
190                            float * pInWalk = pinArr;
191                            float * pInEnd = pinArr + X.S.NumberOfElements;
192                            Int32 * pRetWalk = pretArr;
193                            while (pInWalk < pInEnd) {
194                                *(pRetWalk++) = ( Int32 ) (*(pInWalk++));
195                            }
196                        }
197                    } else if (retArrGen is  byte []) {
198             byte [] dummyArray = ( byte [])(object)retArrGen;
199                        fixed ( byte * pretArr = dummyArray)
200                        fixed (float * pinArr = inArr) {
201                            float * pInWalk = pinArr;
202                            float * pInEnd = pinArr + X.S.NumberOfElements;
203                            byte * pRetWalk = pretArr;
204                            while (pInWalk < pInEnd) {
205                                *(pRetWalk++) = ( byte ) (*(pInWalk++));
206                            }
207                        }
208                    } else if (retArrGen is  fcomplex []) {
209             fcomplex [] dummyArray = ( fcomplex [])(object)retArrGen;
210                        fixed ( fcomplex * pretArr = dummyArray)
211                        fixed (float * pinArr = inArr) {
212                            float * pInWalk = pinArr;
213                            float * pInEnd = pinArr + X.S.NumberOfElements;
214                            fcomplex * pRetWalk = pretArr;
215                            while (pInWalk < pInEnd) {
216                                *(pRetWalk++) = ( fcomplex ) (*(pInWalk++));
217                            }
218                        }
219                    } else if (retArrGen is  complex []) {
220             complex [] dummyArray = ( complex [])(object)retArrGen;
221                        fixed ( complex * pretArr = dummyArray)
222                        fixed (float * pinArr = inArr) {
223                            float * pInWalk = pinArr;
224                            float * pInEnd = pinArr + X.S.NumberOfElements;
225                            complex * pRetWalk = pretArr;
226                            while (pInWalk < pInEnd) {
227                                *(pRetWalk++) = ( complex ) (*(pInWalk++));
228                            }
229                        }
230                    } else if (retArrGen is  float []) {
231             float [] dummyArray = ( float [])(object)retArrGen;
232                        fixed ( float * pretArr = dummyArray)
233                        fixed (float * pinArr = inArr) {
234                            float * pInWalk = pinArr;
235                            float * pInEnd = pinArr + X.S.NumberOfElements;
236                            float * pRetWalk = pretArr;
237                            while (pInWalk < pInEnd) {
238                                *(pRetWalk++) = ( float ) (*(pInWalk++));
239                            }
240                        }
241
242#endregion HYCALPER AUTO GENERATED CODE
243                   } else
244                        throw new ILArgumentException("unsupported target type: " + typeof(outT).Name);
245    #endregion
246                } else if (inArrGen is complex[]) {
247    #region input complex
248                    complex[] inArr = (complex[])(object)inArrGen; 
249                    if (false) {
250
251                    } else if (retArrGen is  double []) {
252             double [] dummyArray = ( double [])(object)retArrGen;
253                        fixed ( double * pretArr = dummyArray)
254                        fixed (complex * pinArr = inArr) {
255                            complex * pInWalk = pinArr;
256                            complex * pInEnd = pinArr + X.S.NumberOfElements;
257                             double * pRetWalk = pretArr;
258                            while (pInWalk < pInEnd) {
259                                *(pRetWalk++) = ( double ) (*(pInWalk++));
260                            }
261                        }
262
263#region HYCALPER AUTO GENERATED CODE
264
265                    } else if (retArrGen is  Int64 []) {
266             Int64 [] dummyArray = ( Int64 [])(object)retArrGen;
267                        fixed ( Int64 * pretArr = dummyArray)
268                        fixed (complex * pinArr = inArr) {
269                            complex * pInWalk = pinArr;
270                            complex * pInEnd = pinArr + X.S.NumberOfElements;
271                            Int64 * pRetWalk = pretArr;
272                            while (pInWalk < pInEnd) {
273                                *(pRetWalk++) = ( Int64 ) (*(pInWalk++));
274                            }
275                        }
276                    } else if (retArrGen is  Int32 []) {
277             Int32 [] dummyArray = ( Int32 [])(object)retArrGen;
278                        fixed ( Int32 * pretArr = dummyArray)
279                        fixed (complex * pinArr = inArr) {
280                            complex * pInWalk = pinArr;
281                            complex * pInEnd = pinArr + X.S.NumberOfElements;
282                            Int32 * pRetWalk = pretArr;
283                            while (pInWalk < pInEnd) {
284                                *(pRetWalk++) = ( Int32 ) (*(pInWalk++));
285                            }
286                        }
287                    } else if (retArrGen is  byte []) {
288             byte [] dummyArray = ( byte [])(object)retArrGen;
289                        fixed ( byte * pretArr = dummyArray)
290                        fixed (complex * pinArr = inArr) {
291                            complex * pInWalk = pinArr;
292                            complex * pInEnd = pinArr + X.S.NumberOfElements;
293                            byte * pRetWalk = pretArr;
294                            while (pInWalk < pInEnd) {
295                                *(pRetWalk++) = ( byte ) (*(pInWalk++));
296                            }
297                        }
298                    } else if (retArrGen is  fcomplex []) {
299             fcomplex [] dummyArray = ( fcomplex [])(object)retArrGen;
300                        fixed ( fcomplex * pretArr = dummyArray)
301                        fixed (complex * pinArr = inArr) {
302                            complex * pInWalk = pinArr;
303                            complex * pInEnd = pinArr + X.S.NumberOfElements;
304                            fcomplex * pRetWalk = pretArr;
305                            while (pInWalk < pInEnd) {
306                                *(pRetWalk++) = ( fcomplex ) (*(pInWalk++));
307                            }
308                        }
309                    } else if (retArrGen is  complex []) {
310             complex [] dummyArray = ( complex [])(object)retArrGen;
311                        fixed ( complex * pretArr = dummyArray)
312                        fixed (complex * pinArr = inArr) {
313                            complex * pInWalk = pinArr;
314                            complex * pInEnd = pinArr + X.S.NumberOfElements;
315                            complex * pRetWalk = pretArr;
316                            while (pInWalk < pInEnd) {
317                                *(pRetWalk++) = ( complex ) (*(pInWalk++));
318                            }
319                        }
320                    } else if (retArrGen is  float []) {
321             float [] dummyArray = ( float [])(object)retArrGen;
322                        fixed ( float * pretArr = dummyArray)
323                        fixed (complex * pinArr = inArr) {
324                            complex * pInWalk = pinArr;
325                            complex * pInEnd = pinArr + X.S.NumberOfElements;
326                            float * pRetWalk = pretArr;
327                            while (pInWalk < pInEnd) {
328                                *(pRetWalk++) = ( float ) (*(pInWalk++));
329                            }
330                        }
331
332#endregion HYCALPER AUTO GENERATED CODE
333                    } else if (retArrGen is Complex[]) {
334                        GCHandle retHandle = GCHandle.Alloc(retArrGen,GCHandleType.Pinned);
335                        GCHandle inHandle = GCHandle.Alloc(inArrGen,GCHandleType.Pinned);
336                        complex* retP = (complex*)retHandle.AddrOfPinnedObject();
337                        complex* inP = (complex*)inHandle.AddrOfPinnedObject();
338                        complex2ComplexHelper(inP, retP, X.S.NumberOfElements);
339                        retHandle.Free();
340                        inHandle.Free();
341                    } else
342                        throw new ILArgumentException("unsupported target type: " + typeof(outT).Name);
343    #endregion
344                } else if (inArrGen is fcomplex[]) {
345    #region input fcomplex
346                    fcomplex[] inArr = (fcomplex[])(object)inArrGen; 
347                    if (false) {
348
349                    } else if (retArrGen is  double []) {
350             double [] dummyArray = ( double [])(object)retArrGen;
351                        fixed ( double * pretArr = dummyArray)
352                        fixed (fcomplex * pinArr = inArr) {
353                            fcomplex * pInWalk = pinArr;
354                            fcomplex * pInEnd = pinArr + X.S.NumberOfElements;
355                             double * pRetWalk = pretArr;
356                            while (pInWalk < pInEnd) {
357                                *(pRetWalk++) = ( double ) (*(pInWalk++));
358                            }
359                        }
360
361#region HYCALPER AUTO GENERATED CODE
362
363                    } else if (retArrGen is  Int64 []) {
364             Int64 [] dummyArray = ( Int64 [])(object)retArrGen;
365                        fixed ( Int64 * pretArr = dummyArray)
366                        fixed (fcomplex * pinArr = inArr) {
367                            fcomplex * pInWalk = pinArr;
368                            fcomplex * pInEnd = pinArr + X.S.NumberOfElements;
369                            Int64 * pRetWalk = pretArr;
370                            while (pInWalk < pInEnd) {
371                                *(pRetWalk++) = ( Int64 ) (*(pInWalk++));
372                            }
373                        }
374                    } else if (retArrGen is  Int32 []) {
375             Int32 [] dummyArray = ( Int32 [])(object)retArrGen;
376                        fixed ( Int32 * pretArr = dummyArray)
377                        fixed (fcomplex * pinArr = inArr) {
378                            fcomplex * pInWalk = pinArr;
379                            fcomplex * pInEnd = pinArr + X.S.NumberOfElements;
380                            Int32 * pRetWalk = pretArr;
381                            while (pInWalk < pInEnd) {
382                                *(pRetWalk++) = ( Int32 ) (*(pInWalk++));
383                            }
384                        }
385                    } else if (retArrGen is  byte []) {
386             byte [] dummyArray = ( byte [])(object)retArrGen;
387                        fixed ( byte * pretArr = dummyArray)
388                        fixed (fcomplex * pinArr = inArr) {
389                            fcomplex * pInWalk = pinArr;
390                            fcomplex * pInEnd = pinArr + X.S.NumberOfElements;
391                            byte * pRetWalk = pretArr;
392                            while (pInWalk < pInEnd) {
393                                *(pRetWalk++) = ( byte ) (*(pInWalk++));
394                            }
395                        }
396                    } else if (retArrGen is  fcomplex []) {
397             fcomplex [] dummyArray = ( fcomplex [])(object)retArrGen;
398                        fixed ( fcomplex * pretArr = dummyArray)
399                        fixed (fcomplex * pinArr = inArr) {
400                            fcomplex * pInWalk = pinArr;
401                            fcomplex * pInEnd = pinArr + X.S.NumberOfElements;
402                            fcomplex * pRetWalk = pretArr;
403                            while (pInWalk < pInEnd) {
404                                *(pRetWalk++) = ( fcomplex ) (*(pInWalk++));
405                            }
406                        }
407                    } else if (retArrGen is  complex []) {
408             complex [] dummyArray = ( complex [])(object)retArrGen;
409                        fixed ( complex * pretArr = dummyArray)
410                        fixed (fcomplex * pinArr = inArr) {
411                            fcomplex * pInWalk = pinArr;
412                            fcomplex * pInEnd = pinArr + X.S.NumberOfElements;
413                            complex * pRetWalk = pretArr;
414                            while (pInWalk < pInEnd) {
415                                *(pRetWalk++) = ( complex ) (*(pInWalk++));
416                            }
417                        }
418                    } else if (retArrGen is  float []) {
419             float [] dummyArray = ( float [])(object)retArrGen;
420                        fixed ( float * pretArr = dummyArray)
421                        fixed (fcomplex * pinArr = inArr) {
422                            fcomplex * pInWalk = pinArr;
423                            fcomplex * pInEnd = pinArr + X.S.NumberOfElements;
424                            float * pRetWalk = pretArr;
425                            while (pInWalk < pInEnd) {
426                                *(pRetWalk++) = ( float ) (*(pInWalk++));
427                            }
428                        }
429
430#endregion HYCALPER AUTO GENERATED CODE
431                   } else
432                        throw new ILArgumentException("unsupported target type: " + typeof(outT).Name);
433    #endregion
434                } else if (inArrGen is byte[]) {
435    #region input byte
436                    byte[] inArr = (byte[])(object)inArrGen; 
437                    if (false) {
438
439                    } else if (retArrGen is  double []) {
440             double [] dummyArray = ( double [])(object)retArrGen;
441                        fixed ( double * pretArr = dummyArray)
442                        fixed (byte * pinArr = inArr) {
443                            byte * pInWalk = pinArr;
444                            byte * pInEnd = pinArr + X.S.NumberOfElements;
445                             double * pRetWalk = pretArr;
446                            while (pInWalk < pInEnd) {
447                                *(pRetWalk++) = ( double ) (*(pInWalk++));
448                            }
449                        }
450
451#region HYCALPER AUTO GENERATED CODE
452
453                    } else if (retArrGen is  Int64 []) {
454             Int64 [] dummyArray = ( Int64 [])(object)retArrGen;
455                        fixed ( Int64 * pretArr = dummyArray)
456                        fixed (byte * pinArr = inArr) {
457                            byte * pInWalk = pinArr;
458                            byte * pInEnd = pinArr + X.S.NumberOfElements;
459                            Int64 * pRetWalk = pretArr;
460                            while (pInWalk < pInEnd) {
461                                *(pRetWalk++) = ( Int64 ) (*(pInWalk++));
462                            }
463                        }
464                    } else if (retArrGen is  Int32 []) {
465             Int32 [] dummyArray = ( Int32 [])(object)retArrGen;
466                        fixed ( Int32 * pretArr = dummyArray)
467                        fixed (byte * pinArr = inArr) {
468                            byte * pInWalk = pinArr;
469                            byte * pInEnd = pinArr + X.S.NumberOfElements;
470                            Int32 * pRetWalk = pretArr;
471                            while (pInWalk < pInEnd) {
472                                *(pRetWalk++) = ( Int32 ) (*(pInWalk++));
473                            }
474                        }
475                    } else if (retArrGen is  byte []) {
476             byte [] dummyArray = ( byte [])(object)retArrGen;
477                        fixed ( byte * pretArr = dummyArray)
478                        fixed (byte * pinArr = inArr) {
479                            byte * pInWalk = pinArr;
480                            byte * pInEnd = pinArr + X.S.NumberOfElements;
481                            byte * pRetWalk = pretArr;
482                            while (pInWalk < pInEnd) {
483                                *(pRetWalk++) = ( byte ) (*(pInWalk++));
484                            }
485                        }
486                    } else if (retArrGen is  fcomplex []) {
487             fcomplex [] dummyArray = ( fcomplex [])(object)retArrGen;
488                        fixed ( fcomplex * pretArr = dummyArray)
489                        fixed (byte * pinArr = inArr) {
490                            byte * pInWalk = pinArr;
491                            byte * pInEnd = pinArr + X.S.NumberOfElements;
492                            fcomplex * pRetWalk = pretArr;
493                            while (pInWalk < pInEnd) {
494                                *(pRetWalk++) = ( fcomplex ) (*(pInWalk++));
495                            }
496                        }
497                    } else if (retArrGen is  complex []) {
498             complex [] dummyArray = ( complex [])(object)retArrGen;
499                        fixed ( complex * pretArr = dummyArray)
500                        fixed (byte * pinArr = inArr) {
501                            byte * pInWalk = pinArr;
502                            byte * pInEnd = pinArr + X.S.NumberOfElements;
503                            complex * pRetWalk = pretArr;
504                            while (pInWalk < pInEnd) {
505                                *(pRetWalk++) = ( complex ) (*(pInWalk++));
506                            }
507                        }
508                    } else if (retArrGen is  float []) {
509             float [] dummyArray = ( float [])(object)retArrGen;
510                        fixed ( float * pretArr = dummyArray)
511                        fixed (byte * pinArr = inArr) {
512                            byte * pInWalk = pinArr;
513                            byte * pInEnd = pinArr + X.S.NumberOfElements;
514                            float * pRetWalk = pretArr;
515                            while (pInWalk < pInEnd) {
516                                *(pRetWalk++) = ( float ) (*(pInWalk++));
517                            }
518                        }
519
520#endregion HYCALPER AUTO GENERATED CODE
521                   } else
522                        throw new ILArgumentException("unsupported target type: " + typeof(outT).Name);
523    #endregion
524                } else if (inArrGen is Int32[]) {
525    #region input Int32
526                    Int32[] inArr = (Int32[])(object)inArrGen; 
527                    if (false) {
528
529                    } else if (retArrGen is  double []) {
530             double [] dummyArray = ( double [])(object)retArrGen;
531                        fixed ( double * pretArr = dummyArray)
532                        fixed (Int32 * pinArr = inArr) {
533                            Int32 * pInWalk = pinArr;
534                            Int32 * pInEnd = pinArr + X.S.NumberOfElements;
535                             double * pRetWalk = pretArr;
536                            while (pInWalk < pInEnd) {
537                                *(pRetWalk++) = ( double ) (*(pInWalk++));
538                            }
539                        }
540
541#region HYCALPER AUTO GENERATED CODE
542
543                    } else if (retArrGen is  Int64 []) {
544             Int64 [] dummyArray = ( Int64 [])(object)retArrGen;
545                        fixed ( Int64 * pretArr = dummyArray)
546                        fixed (Int32 * pinArr = inArr) {
547                            Int32 * pInWalk = pinArr;
548                            Int32 * pInEnd = pinArr + X.S.NumberOfElements;
549                            Int64 * pRetWalk = pretArr;
550                            while (pInWalk < pInEnd) {
551                                *(pRetWalk++) = ( Int64 ) (*(pInWalk++));
552                            }
553                        }
554                    } else if (retArrGen is  Int32 []) {
555             Int32 [] dummyArray = ( Int32 [])(object)retArrGen;
556                        fixed ( Int32 * pretArr = dummyArray)
557                        fixed (Int32 * pinArr = inArr) {
558                            Int32 * pInWalk = pinArr;
559                            Int32 * pInEnd = pinArr + X.S.NumberOfElements;
560                            Int32 * pRetWalk = pretArr;
561                            while (pInWalk < pInEnd) {
562                                *(pRetWalk++) = ( Int32 ) (*(pInWalk++));
563                            }
564                        }
565                    } else if (retArrGen is  byte []) {
566             byte [] dummyArray = ( byte [])(object)retArrGen;
567                        fixed ( byte * pretArr = dummyArray)
568                        fixed (Int32 * pinArr = inArr) {
569                            Int32 * pInWalk = pinArr;
570                            Int32 * pInEnd = pinArr + X.S.NumberOfElements;
571                            byte * pRetWalk = pretArr;
572                            while (pInWalk < pInEnd) {
573                                *(pRetWalk++) = ( byte ) (*(pInWalk++));
574                            }
575                        }
576                    } else if (retArrGen is  fcomplex []) {
577             fcomplex [] dummyArray = ( fcomplex [])(object)retArrGen;
578                        fixed ( fcomplex * pretArr = dummyArray)
579                        fixed (Int32 * pinArr = inArr) {
580                            Int32 * pInWalk = pinArr;
581                            Int32 * pInEnd = pinArr + X.S.NumberOfElements;
582                            fcomplex * pRetWalk = pretArr;
583                            while (pInWalk < pInEnd) {
584                                *(pRetWalk++) = ( fcomplex ) (*(pInWalk++));
585                            }
586                        }
587                    } else if (retArrGen is  complex []) {
588             complex [] dummyArray = ( complex [])(object)retArrGen;
589                        fixed ( complex * pretArr = dummyArray)
590                        fixed (Int32 * pinArr = inArr) {
591                            Int32 * pInWalk = pinArr;
592                            Int32 * pInEnd = pinArr + X.S.NumberOfElements;
593                            complex * pRetWalk = pretArr;
594                            while (pInWalk < pInEnd) {
595                                *(pRetWalk++) = ( complex ) (*(pInWalk++));
596                            }
597                        }
598                    } else if (retArrGen is  float []) {
599             float [] dummyArray = ( float [])(object)retArrGen;
600                        fixed ( float * pretArr = dummyArray)
601                        fixed (Int32 * pinArr = inArr) {
602                            Int32 * pInWalk = pinArr;
603                            Int32 * pInEnd = pinArr + X.S.NumberOfElements;
604                            float * pRetWalk = pretArr;
605                            while (pInWalk < pInEnd) {
606                                *(pRetWalk++) = ( float ) (*(pInWalk++));
607                            }
608                        }
609
610#endregion HYCALPER AUTO GENERATED CODE
611                   } else
612                        throw new ILArgumentException("unsupported target type: " + typeof(outT).Name);
613    #endregion
614                } else if (inArrGen is Int64[]) {
615    #region input Int64
616                    Int64[] inArr = (Int64[])(object)inArrGen; 
617                    if (false) {
618
619                    } else if (retArrGen is  double []) {
620             double [] dummyArray = ( double [])(object)retArrGen;
621                        fixed ( double * pretArr = dummyArray)
622                        fixed (Int64 * pinArr = inArr) {
623                            Int64 * pInWalk = pinArr;
624                            Int64 * pInEnd = pinArr + X.S.NumberOfElements;
625                             double * pRetWalk = pretArr;
626                            while (pInWalk < pInEnd) {
627                                *(pRetWalk++) = ( double ) (*(pInWalk++));
628                            }
629                        }
630
631#region HYCALPER AUTO GENERATED CODE
632
633                    } else if (retArrGen is  Int64 []) {
634             Int64 [] dummyArray = ( Int64 [])(object)retArrGen;
635                        fixed ( Int64 * pretArr = dummyArray)
636                        fixed (Int64 * pinArr = inArr) {
637                            Int64 * pInWalk = pinArr;
638                            Int64 * pInEnd = pinArr + X.S.NumberOfElements;
639                            Int64 * pRetWalk = pretArr;
640                            while (pInWalk < pInEnd) {
641                                *(pRetWalk++) = ( Int64 ) (*(pInWalk++));
642                            }
643                        }
644                    } else if (retArrGen is  Int32 []) {
645             Int32 [] dummyArray = ( Int32 [])(object)retArrGen;
646                        fixed ( Int32 * pretArr = dummyArray)
647                        fixed (Int64 * pinArr = inArr) {
648                            Int64 * pInWalk = pinArr;
649                            Int64 * pInEnd = pinArr + X.S.NumberOfElements;
650                            Int32 * pRetWalk = pretArr;
651                            while (pInWalk < pInEnd) {
652                                *(pRetWalk++) = ( Int32 ) (*(pInWalk++));
653                            }
654                        }
655                    } else if (retArrGen is  byte []) {
656             byte [] dummyArray = ( byte [])(object)retArrGen;
657                        fixed ( byte * pretArr = dummyArray)
658                        fixed (Int64 * pinArr = inArr) {
659                            Int64 * pInWalk = pinArr;
660                            Int64 * pInEnd = pinArr + X.S.NumberOfElements;
661                            byte * pRetWalk = pretArr;
662                            while (pInWalk < pInEnd) {
663                                *(pRetWalk++) = ( byte ) (*(pInWalk++));
664                            }
665                        }
666                    } else if (retArrGen is  fcomplex []) {
667             fcomplex [] dummyArray = ( fcomplex [])(object)retArrGen;
668                        fixed ( fcomplex * pretArr = dummyArray)
669                        fixed (Int64 * pinArr = inArr) {
670                            Int64 * pInWalk = pinArr;
671                            Int64 * pInEnd = pinArr + X.S.NumberOfElements;
672                            fcomplex * pRetWalk = pretArr;
673                            while (pInWalk < pInEnd) {
674                                *(pRetWalk++) = ( fcomplex ) (*(pInWalk++));
675                            }
676                        }
677                    } else if (retArrGen is  complex []) {
678             complex [] dummyArray = ( complex [])(object)retArrGen;
679                        fixed ( complex * pretArr = dummyArray)
680                        fixed (Int64 * pinArr = inArr) {
681                            Int64 * pInWalk = pinArr;
682                            Int64 * pInEnd = pinArr + X.S.NumberOfElements;
683                            complex * pRetWalk = pretArr;
684                            while (pInWalk < pInEnd) {
685                                *(pRetWalk++) = ( complex ) (*(pInWalk++));
686                            }
687                        }
688                    } else if (retArrGen is  float []) {
689             float [] dummyArray = ( float [])(object)retArrGen;
690                        fixed ( float * pretArr = dummyArray)
691                        fixed (Int64 * pinArr = inArr) {
692                            Int64 * pInWalk = pinArr;
693                            Int64 * pInEnd = pinArr + X.S.NumberOfElements;
694                            float * pRetWalk = pretArr;
695                            while (pInWalk < pInEnd) {
696                                *(pRetWalk++) = ( float ) (*(pInWalk++));
697                            }
698                        }
699
700#endregion HYCALPER AUTO GENERATED CODE
701                   } else
702                        throw new ILArgumentException("unsupported target type: " + typeof(outT).Name);
703    #endregion
704                } else if (inArrGen is Complex[] && retArrGen is complex[]) {
705                    GCHandle retHandle = GCHandle.Alloc(retArrGen, GCHandleType.Pinned);
706                    GCHandle inHandle = GCHandle.Alloc(inArrGen, GCHandleType.Pinned);
707                    complex* retP = (complex*)retHandle.AddrOfPinnedObject();
708                    complex* inP = (complex*)inHandle.AddrOfPinnedObject();
709                    complex2ComplexHelper(inP, retP, X.S.NumberOfElements);
710                    retHandle.Free();
711                    inHandle.Free();
712                } else
713                    throw new ILArgumentException(String.Format("conversion from {0} to {1} is currently not supported.", typeof(inT).Name, typeof(outT).Name));
714                return new ILRetArray<outT>(retArrGen,X.Size);
715            }
716        }
717
718        unsafe internal static void complex2ComplexHelper(complex* inArr, complex* outArr, int len) {
719            while (len > 8) {
720                outArr[0] = inArr[0];
721                outArr[1] = inArr[1];
722                outArr[2] = inArr[2];
723                outArr[3] = inArr[3];
724                outArr[4] = inArr[4];
725                outArr[5] = inArr[5];
726                outArr[6] = inArr[6];
727                outArr[7] = inArr[7];
728                inArr += 8; outArr += 8; len -= 8;
729            }
730            while (len-- > 0) *outArr++ = *inArr++;
731        }
732       
733
734        /// <summary>
735        /// Convert numeric array to double array
736        /// </summary>
737        /// <param name="X">Input array</param>
738        /// <returns>double array</returns>
739        /// <remarks><para>The function converts elements of X to double using standard explicit system conversions.
740        /// The new array uses new memory, even if the incoming type is the same as the output type.</para></remarks>
741        public static ILRetArray<double> todouble(ILInArray< double > X) {
742             return convert< double ,double>(X);
743        }
744        /// <summary>
745        /// Convert numeric array to float array
746        /// </summary>
747        /// <param name="X">Input array</param>
748        /// <returns>float array</returns>
749        /// <remarks><para>The new array converts elements of X to float using standard explicit system conversions.
750        /// The new array uses new memory, even if the incoming type is the same as the output type.</para></remarks>
751        public static ILRetArray<float> tosingle(ILInArray< double > X) {
752             return convert< double ,float>(X);
753        }
754        /// <summary>
755        /// Convert numeric array to complex array
756        /// </summary>
757        /// <param name="X">Input array </param>
758        /// <returns>complex array</returns>
759        /// <remarks><para>Real input arrays will be converted to the real part of the complex array returned.</para>
760        /// <para>The function converts elements of X to complex using standard explicit system conversions.
761        /// The new array uses new memory, even if the incoming type is the same as the output type.</para></remarks>
762        public static ILRetArray<complex> tocomplex(ILInArray< double > X) {
763             return convert< double ,complex>(X);
764        }
765        /// <summary>
766        /// Convert numeric array to fcomplex array
767        /// </summary>
768        /// <param name="X">Input array </param>
769        /// <returns>fcomplex array</returns>
770        /// <remarks>
771        /// <para>Real input arrays are converted to the real part of the complex array returned.</para>
772        /// <para>The function converts elements of X to fcomplex using standard explicit system conversions.
773        /// The new array uses new memory, even if the incoming type is the same as the output type.</para></remarks>
774        public static ILRetArray<fcomplex> tofcomplex(ILInArray< double > X) {
775             return convert< double ,fcomplex>(X);
776        }
777        /// <summary>
778        /// Convert numeric array to byte array
779        /// </summary>
780        /// <param name="X">Input array </param>
781        /// <returns>byte array</returns>
782        /// <remarks><para>The function converts elements of X to byte using standard explicit system conversions.
783        /// The new array uses new memory, even if the incoming type is the same as the output type.</para></remarks>
784        public static ILRetArray<byte> tobyte(ILInArray< double > X) {
785             return convert< double ,byte>(X);
786        }
787        /// <summary>
788        /// Convert numeric array to logical array
789        /// </summary>
790        /// <param name="X">Input array </param>
791        /// <returns>Logical array</returns>
792        /// <remarks><para>The function converts elements of X to byte using standard explicit system conversions. Non-zero
793        /// elements are converted to true, zero-elements are converted to false.
794        /// The new array will always use new memory, even if the incoming type is the same as the output type.</para></remarks>
795        public static ILRetLogical tological(ILInArray< double > X) {
796             return new ILRetLogical (convert< double ,byte>(X).Storage as ILDenseStorage<byte>);
797        }
798        /// <summary>
799        /// Convert numeric array to Int32 array
800        /// </summary>
801        /// <param name="X">Input array </param>
802        /// <returns>Int32 array</returns>
803        /// <remarks><para>The function converts elements of X to Int32 using standard explicit system conversions. 
804        /// The new array will always use new memory, even if the incoming type is the same as the output type.</para></remarks>
805        public static ILRetArray<Int32> toint32(ILInArray< double > X) {
806             return convert< double ,Int32>(X);
807        }
808        /// <summary>
809        /// Convert numeric array to Int64 array
810        /// </summary>
811        /// <param name="X">Input array </param>
812        /// <returns>Int64 array</returns>
813        /// <remarks><para>The function converts elements of X to Int64 using standard explicit system conversions. 
814        /// The new array will always use new memory, even if the incoming type is the same as the output type.</para></remarks>
815        public static ILRetArray<Int64> toint64(ILInArray< double > X) {
816             return convert< double ,Int64>(X);
817        }
818
819#region HYCALPER AUTO GENERATED CODE
820
821        /// <summary>
822        /// Convert numeric array to double array
823        /// </summary>
824        /// <param name="X">Input array</param>
825        /// <returns>double array</returns>
826        /// <remarks><para>The function converts elements of X to double using standard explicit system conversions.
827        /// The new array uses new memory, even if the incoming type is the same as the output type.</para></remarks>
828        public static ILRetArray<double> todouble(ILInArray< Int64 > X) {
829             return convert< Int64 ,double>(X);
830        }
831        /// <summary>
832        /// Convert numeric array to float array
833        /// </summary>
834        /// <param name="X">Input array</param>
835        /// <returns>float array</returns>
836        /// <remarks><para>The new array converts elements of X to float using standard explicit system conversions.
837        /// The new array uses new memory, even if the incoming type is the same as the output type.</para></remarks>
838        public static ILRetArray<float> tosingle(ILInArray< Int64 > X) {
839             return convert< Int64 ,float>(X);
840        }
841        /// <summary>
842        /// Convert numeric array to complex array
843        /// </summary>
844        /// <param name="X">Input array </param>
845        /// <returns>complex array</returns>
846        /// <remarks><para>Real input arrays will be converted to the real part of the complex array returned.</para>
847        /// <para>The function converts elements of X to complex using standard explicit system conversions.
848        /// The new array uses new memory, even if the incoming type is the same as the output type.</para></remarks>
849        public static ILRetArray<complex> tocomplex(ILInArray< Int64 > X) {
850             return convert< Int64 ,complex>(X);
851        }
852        /// <summary>
853        /// Convert numeric array to fcomplex array
854        /// </summary>
855        /// <param name="X">Input array </param>
856        /// <returns>fcomplex array</returns>
857        /// <remarks>
858        /// <para>Real input arrays are converted to the real part of the complex array returned.</para>
859        /// <para>The function converts elements of X to fcomplex using standard explicit system conversions.
860        /// The new array uses new memory, even if the incoming type is the same as the output type.</para></remarks>
861        public static ILRetArray<fcomplex> tofcomplex(ILInArray< Int64 > X) {
862             return convert< Int64 ,fcomplex>(X);
863        }
864        /// <summary>
865        /// Convert numeric array to byte array
866        /// </summary>
867        /// <param name="X">Input array </param>
868        /// <returns>byte array</returns>
869        /// <remarks><para>The function converts elements of X to byte using standard explicit system conversions.
870        /// The new array uses new memory, even if the incoming type is the same as the output type.</para></remarks>
871        public static ILRetArray<byte> tobyte(ILInArray< Int64 > X) {
872             return convert< Int64 ,byte>(X);
873        }
874        /// <summary>
875        /// Convert numeric array to logical array
876        /// </summary>
877        /// <param name="X">Input array </param>
878        /// <returns>Logical array</returns>
879        /// <remarks><para>The function converts elements of X to byte using standard explicit system conversions. Non-zero
880        /// elements are converted to true, zero-elements are converted to false.
881        /// The new array will always use new memory, even if the incoming type is the same as the output type.</para></remarks>
882        public static ILRetLogical tological(ILInArray< Int64 > X) {
883             return new ILRetLogical (convert< Int64 ,byte>(X).Storage as ILDenseStorage<byte>);
884        }
885        /// <summary>
886        /// Convert numeric array to Int32 array
887        /// </summary>
888        /// <param name="X">Input array </param>
889        /// <returns>Int32 array</returns>
890        /// <remarks><para>The function converts elements of X to Int32 using standard explicit system conversions. 
891        /// The new array will always use new memory, even if the incoming type is the same as the output type.</para></remarks>
892        public static ILRetArray<Int32> toint32(ILInArray< Int64 > X) {
893             return convert< Int64 ,Int32>(X);
894        }
895        /// <summary>
896        /// Convert numeric array to Int64 array
897        /// </summary>
898        /// <param name="X">Input array </param>
899        /// <returns>Int64 array</returns>
900        /// <remarks><para>The function converts elements of X to Int64 using standard explicit system conversions. 
901        /// The new array will always use new memory, even if the incoming type is the same as the output type.</para></remarks>
902        public static ILRetArray<Int64> toint64(ILInArray< Int64 > X) {
903             return convert< Int64 ,Int64>(X);
904        }
905        /// <summary>
906        /// Convert numeric array to double array
907        /// </summary>
908        /// <param name="X">Input array</param>
909        /// <returns>double array</returns>
910        /// <remarks><para>The function converts elements of X to double using standard explicit system conversions.
911        /// The new array uses new memory, even if the incoming type is the same as the output type.</para></remarks>
912        public static ILRetArray<double> todouble(ILInArray< Int32 > X) {
913             return convert< Int32 ,double>(X);
914        }
915        /// <summary>
916        /// Convert numeric array to float array
917        /// </summary>
918        /// <param name="X">Input array</param>
919        /// <returns>float array</returns>
920        /// <remarks><para>The new array converts elements of X to float using standard explicit system conversions.
921        /// The new array uses new memory, even if the incoming type is the same as the output type.</para></remarks>
922        public static ILRetArray<float> tosingle(ILInArray< Int32 > X) {
923             return convert< Int32 ,float>(X);
924        }
925        /// <summary>
926        /// Convert numeric array to complex array
927        /// </summary>
928        /// <param name="X">Input array </param>
929        /// <returns>complex array</returns>
930        /// <remarks><para>Real input arrays will be converted to the real part of the complex array returned.</para>
931        /// <para>The function converts elements of X to complex using standard explicit system conversions.
932        /// The new array uses new memory, even if the incoming type is the same as the output type.</para></remarks>
933        public static ILRetArray<complex> tocomplex(ILInArray< Int32 > X) {
934             return convert< Int32 ,complex>(X);
935        }
936        /// <summary>
937        /// Convert numeric array to fcomplex array
938        /// </summary>
939        /// <param name="X">Input array </param>
940        /// <returns>fcomplex array</returns>
941        /// <remarks>
942        /// <para>Real input arrays are converted to the real part of the complex array returned.</para>
943        /// <para>The function converts elements of X to fcomplex using standard explicit system conversions.
944        /// The new array uses new memory, even if the incoming type is the same as the output type.</para></remarks>
945        public static ILRetArray<fcomplex> tofcomplex(ILInArray< Int32 > X) {
946             return convert< Int32 ,fcomplex>(X);
947        }
948        /// <summary>
949        /// Convert numeric array to byte array
950        /// </summary>
951        /// <param name="X">Input array </param>
952        /// <returns>byte array</returns>
953        /// <remarks><para>The function converts elements of X to byte using standard explicit system conversions.
954        /// The new array uses new memory, even if the incoming type is the same as the output type.</para></remarks>
955        public static ILRetArray<byte> tobyte(ILInArray< Int32 > X) {
956             return convert< Int32 ,byte>(X);
957        }
958        /// <summary>
959        /// Convert numeric array to logical array
960        /// </summary>
961        /// <param name="X">Input array </param>
962        /// <returns>Logical array</returns>
963        /// <remarks><para>The function converts elements of X to byte using standard explicit system conversions. Non-zero
964        /// elements are converted to true, zero-elements are converted to false.
965        /// The new array will always use new memory, even if the incoming type is the same as the output type.</para></remarks>
966        public static ILRetLogical tological(ILInArray< Int32 > X) {
967             return new ILRetLogical (convert< Int32 ,byte>(X).Storage as ILDenseStorage<byte>);
968        }
969        /// <summary>
970        /// Convert numeric array to Int32 array
971        /// </summary>
972        /// <param name="X">Input array </param>
973        /// <returns>Int32 array</returns>
974        /// <remarks><para>The function converts elements of X to Int32 using standard explicit system conversions. 
975        /// The new array will always use new memory, even if the incoming type is the same as the output type.</para></remarks>
976        public static ILRetArray<Int32> toint32(ILInArray< Int32 > X) {
977             return convert< Int32 ,Int32>(X);
978        }
979        /// <summary>
980        /// Convert numeric array to Int64 array
981        /// </summary>
982        /// <param name="X">Input array </param>
983        /// <returns>Int64 array</returns>
984        /// <remarks><para>The function converts elements of X to Int64 using standard explicit system conversions. 
985        /// The new array will always use new memory, even if the incoming type is the same as the output type.</para></remarks>
986        public static ILRetArray<Int64> toint64(ILInArray< Int32 > X) {
987             return convert< Int32 ,Int64>(X);
988        }
989        /// <summary>
990        /// Convert numeric array to double array
991        /// </summary>
992        /// <param name="X">Input array</param>
993        /// <returns>double array</returns>
994        /// <remarks><para>The function converts elements of X to double using standard explicit system conversions.
995        /// The new array uses new memory, even if the incoming type is the same as the output type.</para></remarks>
996        public static ILRetArray<double> todouble(ILInArray< byte > X) {
997             return convert< byte ,double>(X);
998        }
999        /// <summary>
1000        /// Convert numeric array to float array
1001        /// </summary>
1002        /// <param name="X">Input array</param>
1003        /// <returns>float array</returns>
1004        /// <remarks><para>The new array converts elements of X to float using standard explicit system conversions.
1005        /// The new array uses new memory, even if the incoming type is the same as the output type.</para></remarks>
1006        public static ILRetArray<float> tosingle(ILInArray< byte > X) {
1007             return convert< byte ,float>(X);
1008        }
1009        /// <summary>
1010        /// Convert numeric array to complex array
1011        /// </summary>
1012        /// <param name="X">Input array </param>
1013        /// <returns>complex array</returns>
1014        /// <remarks><para>Real input arrays will be converted to the real part of the complex array returned.</para>
1015        /// <para>The function converts elements of X to complex using standard explicit system conversions.
1016        /// The new array uses new memory, even if the incoming type is the same as the output type.</para></remarks>
1017        public static ILRetArray<complex> tocomplex(ILInArray< byte > X) {
1018             return convert< byte ,complex>(X);
1019        }
1020        /// <summary>
1021        /// Convert numeric array to fcomplex array
1022        /// </summary>
1023        /// <param name="X">Input array </param>
1024        /// <returns>fcomplex array</returns>
1025        /// <remarks>
1026        /// <para>Real input arrays are converted to the real part of the complex array returned.</para>
1027        /// <para>The function converts elements of X to fcomplex using standard explicit system conversions.
1028        /// The new array uses new memory, even if the incoming type is the same as the output type.</para></remarks>
1029        public static ILRetArray<fcomplex> tofcomplex(ILInArray< byte > X) {
1030             return convert< byte ,fcomplex>(X);
1031        }
1032        /// <summary>
1033        /// Convert numeric array to byte array
1034        /// </summary>
1035        /// <param name="X">Input array </param>
1036        /// <returns>byte array</returns>
1037        /// <remarks><para>The function converts elements of X to byte using standard explicit system conversions.
1038        /// The new array uses new memory, even if the incoming type is the same as the output type.</para></remarks>
1039        public static ILRetArray<byte> tobyte(ILInArray< byte > X) {
1040             return convert< byte ,byte>(X);
1041        }
1042        /// <summary>
1043        /// Convert numeric array to logical array
1044        /// </summary>
1045        /// <param name="X">Input array </param>
1046        /// <returns>Logical array</returns>
1047        /// <remarks><para>The function converts elements of X to byte using standard explicit system conversions. Non-zero
1048        /// elements are converted to true, zero-elements are converted to false.
1049        /// The new array will always use new memory, even if the incoming type is the same as the output type.</para></remarks>
1050        public static ILRetLogical tological(ILInArray< byte > X) {
1051             return new ILRetLogical (convert< byte ,byte>(X).Storage as ILDenseStorage<byte>);
1052        }
1053        /// <summary>
1054        /// Convert numeric array to Int32 array
1055        /// </summary>
1056        /// <param name="X">Input array </param>
1057        /// <returns>Int32 array</returns>
1058        /// <remarks><para>The function converts elements of X to Int32 using standard explicit system conversions. 
1059        /// The new array will always use new memory, even if the incoming type is the same as the output type.</para></remarks>
1060        public static ILRetArray<Int32> toint32(ILInArray< byte > X) {
1061             return convert< byte ,Int32>(X);
1062        }
1063        /// <summary>
1064        /// Convert numeric array to Int64 array
1065        /// </summary>
1066        /// <param name="X">Input array </param>
1067        /// <returns>Int64 array</returns>
1068        /// <remarks><para>The function converts elements of X to Int64 using standard explicit system conversions. 
1069        /// The new array will always use new memory, even if the incoming type is the same as the output type.</para></remarks>
1070        public static ILRetArray<Int64> toint64(ILInArray< byte > X) {
1071             return convert< byte ,Int64>(X);
1072        }
1073        /// <summary>
1074        /// Convert numeric array to double array
1075        /// </summary>
1076        /// <param name="X">Input array</param>
1077        /// <returns>double array</returns>
1078        /// <remarks><para>The function converts elements of X to double using standard explicit system conversions.
1079        /// The new array uses new memory, even if the incoming type is the same as the output type.</para></remarks>
1080        public static ILRetArray<double> todouble(ILInArray< fcomplex > X) {
1081             return convert< fcomplex ,double>(X);
1082        }
1083        /// <summary>
1084        /// Convert numeric array to float array
1085        /// </summary>
1086        /// <param name="X">Input array</param>
1087        /// <returns>float array</returns>
1088        /// <remarks><para>The new array converts elements of X to float using standard explicit system conversions.
1089        /// The new array uses new memory, even if the incoming type is the same as the output type.</para></remarks>
1090        public static ILRetArray<float> tosingle(ILInArray< fcomplex > X) {
1091             return convert< fcomplex ,float>(X);
1092        }
1093        /// <summary>
1094        /// Convert numeric array to complex array
1095        /// </summary>
1096        /// <param name="X">Input array </param>
1097        /// <returns>complex array</returns>
1098        /// <remarks><para>Real input arrays will be converted to the real part of the complex array returned.</para>
1099        /// <para>The function converts elements of X to complex using standard explicit system conversions.
1100        /// The new array uses new memory, even if the incoming type is the same as the output type.</para></remarks>
1101        public static ILRetArray<complex> tocomplex(ILInArray< fcomplex > X) {
1102             return convert< fcomplex ,complex>(X);
1103        }
1104        /// <summary>
1105        /// Convert numeric array to fcomplex array
1106        /// </summary>
1107        /// <param name="X">Input array </param>
1108        /// <returns>fcomplex array</returns>
1109        /// <remarks>
1110        /// <para>Real input arrays are converted to the real part of the complex array returned.</para>
1111        /// <para>The function converts elements of X to fcomplex using standard explicit system conversions.
1112        /// The new array uses new memory, even if the incoming type is the same as the output type.</para></remarks>
1113        public static ILRetArray<fcomplex> tofcomplex(ILInArray< fcomplex > X) {
1114             return convert< fcomplex ,fcomplex>(X);
1115        }
1116        /// <summary>
1117        /// Convert numeric array to byte array
1118        /// </summary>
1119        /// <param name="X">Input array </param>
1120        /// <returns>byte array</returns>
1121        /// <remarks><para>The function converts elements of X to byte using standard explicit system conversions.
1122        /// The new array uses new memory, even if the incoming type is the same as the output type.</para></remarks>
1123        public static ILRetArray<byte> tobyte(ILInArray< fcomplex > X) {
1124             return convert< fcomplex ,byte>(X);
1125        }
1126        /// <summary>
1127        /// Convert numeric array to logical array
1128        /// </summary>
1129        /// <param name="X">Input array </param>
1130        /// <returns>Logical array</returns>
1131        /// <remarks><para>The function converts elements of X to byte using standard explicit system conversions. Non-zero
1132        /// elements are converted to true, zero-elements are converted to false.
1133        /// The new array will always use new memory, even if the incoming type is the same as the output type.</para></remarks>
1134        public static ILRetLogical tological(ILInArray< fcomplex > X) {
1135             return new ILRetLogical (convert< fcomplex ,byte>(X).Storage as ILDenseStorage<byte>);
1136        }
1137        /// <summary>
1138        /// Convert numeric array to Int32 array
1139        /// </summary>
1140        /// <param name="X">Input array </param>
1141        /// <returns>Int32 array</returns>
1142        /// <remarks><para>The function converts elements of X to Int32 using standard explicit system conversions. 
1143        /// The new array will always use new memory, even if the incoming type is the same as the output type.</para></remarks>
1144        public static ILRetArray<Int32> toint32(ILInArray< fcomplex > X) {
1145             return convert< fcomplex ,Int32>(X);
1146        }
1147        /// <summary>
1148        /// Convert numeric array to Int64 array
1149        /// </summary>
1150        /// <param name="X">Input array </param>
1151        /// <returns>Int64 array</returns>
1152        /// <remarks><para>The function converts elements of X to Int64 using standard explicit system conversions. 
1153        /// The new array will always use new memory, even if the incoming type is the same as the output type.</para></remarks>
1154        public static ILRetArray<Int64> toint64(ILInArray< fcomplex > X) {
1155             return convert< fcomplex ,Int64>(X);
1156        }
1157        /// <summary>
1158        /// Convert numeric array to double array
1159        /// </summary>
1160        /// <param name="X">Input array</param>
1161        /// <returns>double array</returns>
1162        /// <remarks><para>The function converts elements of X to double using standard explicit system conversions.
1163        /// The new array uses new memory, even if the incoming type is the same as the output type.</para></remarks>
1164        public static ILRetArray<double> todouble(ILInArray< complex > X) {
1165             return convert< complex ,double>(X);
1166        }
1167        /// <summary>
1168        /// Convert numeric array to float array
1169        /// </summary>
1170        /// <param name="X">Input array</param>
1171        /// <returns>float array</returns>
1172        /// <remarks><para>The new array converts elements of X to float using standard explicit system conversions.
1173        /// The new array uses new memory, even if the incoming type is the same as the output type.</para></remarks>
1174        public static ILRetArray<float> tosingle(ILInArray< complex > X) {
1175             return convert< complex ,float>(X);
1176        }
1177        /// <summary>
1178        /// Convert numeric array to complex array
1179        /// </summary>
1180        /// <param name="X">Input array </param>
1181        /// <returns>complex array</returns>
1182        /// <remarks><para>Real input arrays will be converted to the real part of the complex array returned.</para>
1183        /// <para>The function converts elements of X to complex using standard explicit system conversions.
1184        /// The new array uses new memory, even if the incoming type is the same as the output type.</para></remarks>
1185        public static ILRetArray<complex> tocomplex(ILInArray< complex > X) {
1186             return convert< complex ,complex>(X);
1187        }
1188        /// <summary>
1189        /// Convert numeric array to fcomplex array
1190        /// </summary>
1191        /// <param name="X">Input array </param>
1192        /// <returns>fcomplex array</returns>
1193        /// <remarks>
1194        /// <para>Real input arrays are converted to the real part of the complex array returned.</para>
1195        /// <para>The function converts elements of X to fcomplex using standard explicit system conversions.
1196        /// The new array uses new memory, even if the incoming type is the same as the output type.</para></remarks>
1197        public static ILRetArray<fcomplex> tofcomplex(ILInArray< complex > X) {
1198             return convert< complex ,fcomplex>(X);
1199        }
1200        /// <summary>
1201        /// Convert numeric array to byte array
1202        /// </summary>
1203        /// <param name="X">Input array </param>
1204        /// <returns>byte array</returns>
1205        /// <remarks><para>The function converts elements of X to byte using standard explicit system conversions.
1206        /// The new array uses new memory, even if the incoming type is the same as the output type.</para></remarks>
1207        public static ILRetArray<byte> tobyte(ILInArray< complex > X) {
1208             return convert< complex ,byte>(X);
1209        }
1210        /// <summary>
1211        /// Convert numeric array to logical array
1212        /// </summary>
1213        /// <param name="X">Input array </param>
1214        /// <returns>Logical array</returns>
1215        /// <remarks><para>The function converts elements of X to byte using standard explicit system conversions. Non-zero
1216        /// elements are converted to true, zero-elements are converted to false.
1217        /// The new array will always use new memory, even if the incoming type is the same as the output type.</para></remarks>
1218        public static ILRetLogical tological(ILInArray< complex > X) {
1219             return new ILRetLogical (convert< complex ,byte>(X).Storage as ILDenseStorage<byte>);
1220        }
1221        /// <summary>
1222        /// Convert numeric array to Int32 array
1223        /// </summary>
1224        /// <param name="X">Input array </param>
1225        /// <returns>Int32 array</returns>
1226        /// <remarks><para>The function converts elements of X to Int32 using standard explicit system conversions. 
1227        /// The new array will always use new memory, even if the incoming type is the same as the output type.</para></remarks>
1228        public static ILRetArray<Int32> toint32(ILInArray< complex > X) {
1229             return convert< complex ,Int32>(X);
1230        }
1231        /// <summary>
1232        /// Convert numeric array to Int64 array
1233        /// </summary>
1234        /// <param name="X">Input array </param>
1235        /// <returns>Int64 array</returns>
1236        /// <remarks><para>The function converts elements of X to Int64 using standard explicit system conversions. 
1237        /// The new array will always use new memory, even if the incoming type is the same as the output type.</para></remarks>
1238        public static ILRetArray<Int64> toint64(ILInArray< complex > X) {
1239             return convert< complex ,Int64>(X);
1240        }
1241        /// <summary>
1242        /// Convert numeric array to double array
1243        /// </summary>
1244        /// <param name="X">Input array</param>
1245        /// <returns>double array</returns>
1246        /// <remarks><para>The function converts elements of X to double using standard explicit system conversions.
1247        /// The new array uses new memory, even if the incoming type is the same as the output type.</para></remarks>
1248        public static ILRetArray<double> todouble(ILInArray< float > X) {
1249             return convert< float ,double>(X);
1250        }
1251        /// <summary>
1252        /// Convert numeric array to float array
1253        /// </summary>
1254        /// <param name="X">Input array</param>
1255        /// <returns>float array</returns>
1256        /// <remarks><para>The new array converts elements of X to float using standard explicit system conversions.
1257        /// The new array uses new memory, even if the incoming type is the same as the output type.</para></remarks>
1258        public static ILRetArray<float> tosingle(ILInArray< float > X) {
1259             return convert< float ,float>(X);
1260        }
1261        /// <summary>
1262        /// Convert numeric array to complex array
1263        /// </summary>
1264        /// <param name="X">Input array </param>
1265        /// <returns>complex array</returns>
1266        /// <remarks><para>Real input arrays will be converted to the real part of the complex array returned.</para>
1267        /// <para>The function converts elements of X to complex using standard explicit system conversions.
1268        /// The new array uses new memory, even if the incoming type is the same as the output type.</para></remarks>
1269        public static ILRetArray<complex> tocomplex(ILInArray< float > X) {
1270             return convert< float ,complex>(X);
1271        }
1272        /// <summary>
1273        /// Convert numeric array to fcomplex array
1274        /// </summary>
1275        /// <param name="X">Input array </param>
1276        /// <returns>fcomplex array</returns>
1277        /// <remarks>
1278        /// <para>Real input arrays are converted to the real part of the complex array returned.</para>
1279        /// <para>The function converts elements of X to fcomplex using standard explicit system conversions.
1280        /// The new array uses new memory, even if the incoming type is the same as the output type.</para></remarks>
1281        public static ILRetArray<fcomplex> tofcomplex(ILInArray< float > X) {
1282             return convert< float ,fcomplex>(X);
1283        }
1284        /// <summary>
1285        /// Convert numeric array to byte array
1286        /// </summary>
1287        /// <param name="X">Input array </param>
1288        /// <returns>byte array</returns>
1289        /// <remarks><para>The function converts elements of X to byte using standard explicit system conversions.
1290        /// The new array uses new memory, even if the incoming type is the same as the output type.</para></remarks>
1291        public static ILRetArray<byte> tobyte(ILInArray< float > X) {
1292             return convert< float ,byte>(X);
1293        }
1294        /// <summary>
1295        /// Convert numeric array to logical array
1296        /// </summary>
1297        /// <param name="X">Input array </param>
1298        /// <returns>Logical array</returns>
1299        /// <remarks><para>The function converts elements of X to byte using standard explicit system conversions. Non-zero
1300        /// elements are converted to true, zero-elements are converted to false.
1301        /// The new array will always use new memory, even if the incoming type is the same as the output type.</para></remarks>
1302        public static ILRetLogical tological(ILInArray< float > X) {
1303             return new ILRetLogical (convert< float ,byte>(X).Storage as ILDenseStorage<byte>);
1304        }
1305        /// <summary>
1306        /// Convert numeric array to Int32 array
1307        /// </summary>
1308        /// <param name="X">Input array </param>
1309        /// <returns>Int32 array</returns>
1310        /// <remarks><para>The function converts elements of X to Int32 using standard explicit system conversions. 
1311        /// The new array will always use new memory, even if the incoming type is the same as the output type.</para></remarks>
1312        public static ILRetArray<Int32> toint32(ILInArray< float > X) {
1313             return convert< float ,Int32>(X);
1314        }
1315        /// <summary>
1316        /// Convert numeric array to Int64 array
1317        /// </summary>
1318        /// <param name="X">Input array </param>
1319        /// <returns>Int64 array</returns>
1320        /// <remarks><para>The function converts elements of X to Int64 using standard explicit system conversions. 
1321        /// The new array will always use new memory, even if the incoming type is the same as the output type.</para></remarks>
1322        public static ILRetArray<Int64> toint64(ILInArray< float > X) {
1323             return convert< float ,Int64>(X);
1324        }
1325
1326#endregion HYCALPER AUTO GENERATED CODE
1327
1328
1329
1330        /// <summary>
1331        /// convert arbitrary numeric array to double array
1332        /// </summary>
1333        /// <param name="X">numeric array, one of supported numeric type</param>
1334        /// <returns>double array</returns>
1335        /// <remarks>This function enables to convert arbitrary numeric (dense) arrays to a known output array type
1336        /// - without knowing the concrete numeric type of the source. Supported element types include: double,
1337        /// float, complex, fcomplex, byte, logical, Int32, Int64.
1338        /// <para>This function will always create new memory for the new array, even if both
1339        /// arrays have the same element type.</para>
1340        /// </remarks>
1341        /// <exception cref="ILNumerics.Exceptions.ILArgumentException">if elements of X are
1342        /// not of any supported numeric type</exception>
1343        public static ILRetArray< double>  todouble(ILBaseArray X) {
1344            using (ILScope.Enter(X)) {
1345                if (X is ILDenseArray<double>)
1346                    return convert<double, double>((X as ILDenseArray<double>).C);
1347                else if (X is ILDenseArray<float>)
1348                    return convert<float, double>((X as ILDenseArray<float>).C);
1349                else if (X is ILDenseArray<complex>)
1350                    return convert<complex, double>((X as ILDenseArray<complex>).C);
1351                else if (X is ILDenseArray<fcomplex>)
1352                    return convert<fcomplex, double>((X as ILDenseArray<fcomplex>).C);
1353                else if (X is ILDenseArray<byte>)
1354                    return convert<byte, double>((X as ILDenseArray<byte>).C);
1355                else if (X is ILDenseArray<Int32>)
1356                    return convert<Int32, double>((X as ILDenseArray<Int32>).C);
1357                else if (X is ILDenseArray<Int64>)
1358                    return convert<Int64, double>((X as ILDenseArray<Int64>).C);
1359                else
1360                    throw new ILArgumentException("input type not supported: " + X.GetType().Name);
1361            }
1362        }
1363
1364#region HYCALPER AUTO GENERATED CODE
1365
1366
1367        /// <summary>convert arbitrary numeric array to Int64 array</summary>
1368        /// <param name="X">numeric array, one of supported numeric type</param>
1369        /// <returns>Int64 array</returns>
1370        /// <remarks>This function enables to convert arbitrary numeric (dense) arrays to a known output array type
1371        /// - without knowing the concrete numeric type of the source. Supported element types include: double,
1372        /// float, complex, fcomplex, byte, logical, Int32, Int64.
1373        /// <para>This function will always create new memory for the new array, even if both
1374        /// arrays have the same element type.</para>
1375        /// </remarks>
1376        /// <exception cref="ILNumerics.Exceptions.ILArgumentException">if elements of X are
1377        /// not of any supported numeric type</exception>
1378        public static ILRetArray< Int64>  toint64(ILBaseArray X) {
1379            using (ILScope.Enter(X)) {
1380                if (X is ILDenseArray<double>)
1381                    return convert<double, Int64>((X as ILDenseArray<double>).C);
1382                else if (X is ILDenseArray<float>)
1383                    return convert<float, Int64>((X as ILDenseArray<float>).C);
1384                else if (X is ILDenseArray<complex>)
1385                    return convert<complex, Int64>((X as ILDenseArray<complex>).C);
1386                else if (X is ILDenseArray<fcomplex>)
1387                    return convert<fcomplex, Int64>((X as ILDenseArray<fcomplex>).C);
1388                else if (X is ILDenseArray<byte>)
1389                    return convert<byte, Int64>((X as ILDenseArray<byte>).C);
1390                else if (X is ILDenseArray<Int32>)
1391                    return convert<Int32, Int64>((X as ILDenseArray<Int32>).C);
1392                else if (X is ILDenseArray<Int64>)
1393                    return convert<Int64, Int64>((X as ILDenseArray<Int64>).C);
1394                else
1395                    throw new ILArgumentException("input type not supported: " + X.GetType().Name);
1396            }
1397        }
1398
1399        /// <summary>convert arbitrary numeric array to Int32 array</summary>
1400        /// <param name="X">numeric array, one of supported numeric type</param>
1401        /// <returns>Int32 array</returns>
1402        /// <remarks>This function enables to convert arbitrary numeric (dense) arrays to a known output array type
1403        /// - without knowing the concrete numeric type of the source. Supported element types include: double,
1404        /// float, complex, fcomplex, byte, logical, Int32, Int64.
1405        /// <para>This function will always create new memory for the new array, even if both
1406        /// arrays have the same element type.</para>
1407        /// </remarks>
1408        /// <exception cref="ILNumerics.Exceptions.ILArgumentException">if elements of X are
1409        /// not of any supported numeric type</exception>
1410        public static ILRetArray< Int32>  toint32(ILBaseArray X) {
1411            using (ILScope.Enter(X)) {
1412                if (X is ILDenseArray<double>)
1413                    return convert<double, Int32>((X as ILDenseArray<double>).C);
1414                else if (X is ILDenseArray<float>)
1415                    return convert<float, Int32>((X as ILDenseArray<float>).C);
1416                else if (X is ILDenseArray<complex>)
1417                    return convert<complex, Int32>((X as ILDenseArray<complex>).C);
1418                else if (X is ILDenseArray<fcomplex>)
1419                    return convert<fcomplex, Int32>((X as ILDenseArray<fcomplex>).C);
1420                else if (X is ILDenseArray<byte>)
1421                    return convert<byte, Int32>((X as ILDenseArray<byte>).C);
1422                else if (X is ILDenseArray<Int32>)
1423                    return convert<Int32, Int32>((X as ILDenseArray<Int32>).C);
1424                else if (X is ILDenseArray<Int64>)
1425                    return convert<Int64, Int32>((X as ILDenseArray<Int64>).C);
1426                else
1427                    throw new ILArgumentException("input type not supported: " + X.GetType().Name);
1428            }
1429        }
1430
1431        /// <summary>convert arbitrary numeric array to byte array</summary>
1432        /// <param name="X">numeric array, one of supported numeric type</param>
1433        /// <returns>byte array</returns>
1434        /// <remarks>This function enables to convert arbitrary numeric (dense) arrays to a known output array type
1435        /// - without knowing the concrete numeric type of the source. Supported element types include: double,
1436        /// float, complex, fcomplex, byte, logical, Int32, Int64.
1437        /// <para>This function will always create new memory for the new array, even if both
1438        /// arrays have the same element type.</para>
1439        /// </remarks>
1440        /// <exception cref="ILNumerics.Exceptions.ILArgumentException">if elements of X are
1441        /// not of any supported numeric type</exception>
1442        public static ILRetArray< byte>  tobyte(ILBaseArray X) {
1443            using (ILScope.Enter(X)) {
1444                if (X is ILDenseArray<double>)
1445                    return convert<double, byte>((X as ILDenseArray<double>).C);
1446                else if (X is ILDenseArray<float>)
1447                    return convert<float, byte>((X as ILDenseArray<float>).C);
1448                else if (X is ILDenseArray<complex>)
1449                    return convert<complex, byte>((X as ILDenseArray<complex>).C);
1450                else if (X is ILDenseArray<fcomplex>)
1451                    return convert<fcomplex, byte>((X as ILDenseArray<fcomplex>).C);
1452                else if (X is ILDenseArray<byte>)
1453                    return convert<byte, byte>((X as ILDenseArray<byte>).C);
1454                else if (X is ILDenseArray<Int32>)
1455                    return convert<Int32, byte>((X as ILDenseArray<Int32>).C);
1456                else if (X is ILDenseArray<Int64>)
1457                    return convert<Int64, byte>((X as ILDenseArray<Int64>).C);
1458                else
1459                    throw new ILArgumentException("input type not supported: " + X.GetType().Name);
1460            }
1461        }
1462
1463        /// <summary>convert arbitrary numeric array to fcomplex array</summary>
1464        /// <param name="X">numeric array, one of supported numeric type</param>
1465        /// <returns>fcomplex array</returns>
1466        /// <remarks>This function enables to convert arbitrary numeric (dense) arrays to a known output array type
1467        /// - without knowing the concrete numeric type of the source. Supported element types include: double,
1468        /// float, complex, fcomplex, byte, logical, Int32, Int64.
1469        /// <para>This function will always create new memory for the new array, even if both
1470        /// arrays have the same element type.</para>
1471        /// </remarks>
1472        /// <exception cref="ILNumerics.Exceptions.ILArgumentException">if elements of X are
1473        /// not of any supported numeric type</exception>
1474        public static ILRetArray< fcomplex>  tofcomplex(ILBaseArray X) {
1475            using (ILScope.Enter(X)) {
1476                if (X is ILDenseArray<double>)
1477                    return convert<double, fcomplex>((X as ILDenseArray<double>).C);
1478                else if (X is ILDenseArray<float>)
1479                    return convert<float, fcomplex>((X as ILDenseArray<float>).C);
1480                else if (X is ILDenseArray<complex>)
1481                    return convert<complex, fcomplex>((X as ILDenseArray<complex>).C);
1482                else if (X is ILDenseArray<fcomplex>)
1483                    return convert<fcomplex, fcomplex>((X as ILDenseArray<fcomplex>).C);
1484                else if (X is ILDenseArray<byte>)
1485                    return convert<byte, fcomplex>((X as ILDenseArray<byte>).C);
1486                else if (X is ILDenseArray<Int32>)
1487                    return convert<Int32, fcomplex>((X as ILDenseArray<Int32>).C);
1488                else if (X is ILDenseArray<Int64>)
1489                    return convert<Int64, fcomplex>((X as ILDenseArray<Int64>).C);
1490                else
1491                    throw new ILArgumentException("input type not supported: " + X.GetType().Name);
1492            }
1493        }
1494
1495        /// <summary>convert arbitrary numeric array to complex array</summary>
1496        /// <param name="X">numeric array, one of supported numeric type</param>
1497        /// <returns>complex array</returns>
1498        /// <remarks>This function enables to convert arbitrary numeric (dense) arrays to a known output array type
1499        /// - without knowing the concrete numeric type of the source. Supported element types include: double,
1500        /// float, complex, fcomplex, byte, logical, Int32, Int64.
1501        /// <para>This function will always create new memory for the new array, even if both
1502        /// arrays have the same element type.</para>
1503        /// </remarks>
1504        /// <exception cref="ILNumerics.Exceptions.ILArgumentException">if elements of X are
1505        /// not of any supported numeric type</exception>
1506        public static ILRetArray< complex>  tocomplex(ILBaseArray X) {
1507            using (ILScope.Enter(X)) {
1508                if (X is ILDenseArray<double>)
1509                    return convert<double, complex>((X as ILDenseArray<double>).C);
1510                else if (X is ILDenseArray<float>)
1511                    return convert<float, complex>((X as ILDenseArray<float>).C);
1512                else if (X is ILDenseArray<complex>)
1513                    return convert<complex, complex>((X as ILDenseArray<complex>).C);
1514                else if (X is ILDenseArray<fcomplex>)
1515                    return convert<fcomplex, complex>((X as ILDenseArray<fcomplex>).C);
1516                else if (X is ILDenseArray<byte>)
1517                    return convert<byte, complex>((X as ILDenseArray<byte>).C);
1518                else if (X is ILDenseArray<Int32>)
1519                    return convert<Int32, complex>((X as ILDenseArray<Int32>).C);
1520                else if (X is ILDenseArray<Int64>)
1521                    return convert<Int64, complex>((X as ILDenseArray<Int64>).C);
1522                else
1523                    throw new ILArgumentException("input type not supported: " + X.GetType().Name);
1524            }
1525        }
1526
1527        /// <summary>convert arbitrary numeric array to float array</summary>
1528        /// <param name="X">numeric array, one of supported numeric type</param>
1529        /// <returns>float array</returns>
1530        /// <remarks>This function enables to convert arbitrary numeric (dense) arrays to a known output array type
1531        /// - without knowing the concrete numeric type of the source. Supported element types include: double,
1532        /// float, complex, fcomplex, byte, logical, Int32, Int64.
1533        /// <para>This function will always create new memory for the new array, even if both
1534        /// arrays have the same element type.</para>
1535        /// </remarks>
1536        /// <exception cref="ILNumerics.Exceptions.ILArgumentException">if elements of X are
1537        /// not of any supported numeric type</exception>
1538        public static ILRetArray< float>  tosingle(ILBaseArray X) {
1539            using (ILScope.Enter(X)) {
1540                if (X is ILDenseArray<double>)
1541                    return convert<double, float>((X as ILDenseArray<double>).C);
1542                else if (X is ILDenseArray<float>)
1543                    return convert<float, float>((X as ILDenseArray<float>).C);
1544                else if (X is ILDenseArray<complex>)
1545                    return convert<complex, float>((X as ILDenseArray<complex>).C);
1546                else if (X is ILDenseArray<fcomplex>)
1547                    return convert<fcomplex, float>((X as ILDenseArray<fcomplex>).C);
1548                else if (X is ILDenseArray<byte>)
1549                    return convert<byte, float>((X as ILDenseArray<byte>).C);
1550                else if (X is ILDenseArray<Int32>)
1551                    return convert<Int32, float>((X as ILDenseArray<Int32>).C);
1552                else if (X is ILDenseArray<Int64>)
1553                    return convert<Int64, float>((X as ILDenseArray<Int64>).C);
1554                else
1555                    throw new ILArgumentException("input type not supported: " + X.GetType().Name);
1556            }
1557        }
1558
1559#endregion HYCALPER AUTO GENERATED CODE
1560
1561    }
1562
1563}
Note: See TracBrowser for help on using the repository browser.