TensorFlow.NET/src/TensorFlowNET.Core/NumPy/NDArray.Implicit.cs at master · mnelsonwhite/TensorFlow.NET · GitHub

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
using System;
using System.Collections.Generic;
using System.Text;

namespace Tensorflow.NumPy
{
    public partial class NDArray
    {
        public void Deconstruct(out byte blue, out byte green, out byte red)
        {
            var data = ToArray<byte>();
            blue = data[0];
            green = data[1];
            red = data[2];
        }

        public static implicit operator NDArray(int[] array)
            => new NDArray(array);

        public static implicit operator NDArray(byte[] array)
            => new NDArray(array);

        public static implicit operator NDArray(float[] array)
            => new NDArray(array);

        public static implicit operator NDArray(double[] array)
            => new NDArray(array);

        public static implicit operator NDArray(long[] array)
            => new NDArray(array);

        public static implicit operator NDArray(bool[] array)
            => new NDArray(array);

        public static implicit operator NDArray(uint[] array)
            => new NDArray(array);

        public static implicit operator NDArray(ulong[] array)
            => new NDArray(array);

        public static implicit operator NDArray(int[,] array)
            => new NDArray(array);

        public static implicit operator NDArray(byte[,] array)
            => new NDArray(array);

        public static implicit operator NDArray(float[,] array)
            => new NDArray(array);

        public static implicit operator NDArray(double[,] array)
            => new NDArray(array);

        public static implicit operator NDArray(long[,] array)
            => new NDArray(array);

        public static implicit operator NDArray(bool[,] array)
            => new NDArray(array);

        public static implicit operator NDArray(uint[,] array)
            => new NDArray(array);

        public static implicit operator NDArray(ulong[,] array)
            => new NDArray(array);

        public static implicit operator NDArray(int[,,] array)
            => new NDArray(array);

        public static implicit operator NDArray(byte[,,] array)
            => new NDArray(array);

        public static implicit operator NDArray(float[,,] array)
            => new NDArray(array);

        public static implicit operator NDArray(double[,,] array)
            => new NDArray(array);

        public static implicit operator NDArray(long[,,] array)
            => new NDArray(array);

        public static implicit operator NDArray(bool[,,] array)
            => new NDArray(array);

        public static implicit operator NDArray(uint[,,] array)
            => new NDArray(array);

        public static implicit operator NDArray(ulong[,,] array)
            => new NDArray(array);

        public unsafe static implicit operator bool(NDArray nd)
            => nd.dtype == TF_DataType.TF_BOOL ? *(bool*)nd.data : NDArrayConverter.Scalar<bool>(nd);

        public unsafe static implicit operator byte(NDArray nd)
            => nd.dtype == TF_DataType.TF_UINT8 ? *(byte*)nd.data : NDArrayConverter.Scalar<byte>(nd);

        public unsafe static implicit operator int(NDArray nd)
            => nd.dtype == TF_DataType.TF_INT32 ? *(int*)nd.data : NDArrayConverter.Scalar<int>(nd);

        public unsafe static implicit operator long(NDArray nd)
            => nd.dtype == TF_DataType.TF_INT64 ? *(long*)nd.data : NDArrayConverter.Scalar<long>(nd);

        public unsafe static implicit operator float(NDArray nd)
            => nd.dtype == TF_DataType.TF_FLOAT ? *(float*)nd.data : NDArrayConverter.Scalar<float>(nd);

        public unsafe static implicit operator double(NDArray nd)
            => nd.dtype == TF_DataType.TF_DOUBLE ? *(double*)nd.data : NDArrayConverter.Scalar<double>(nd);

        public static implicit operator NDArray(bool value)
            => new NDArray(value);

        public static implicit operator NDArray(byte value)
            => new NDArray(value);

        public static implicit operator NDArray(int value)
            => new NDArray(value);

        public static implicit operator NDArray(long value)
            => new NDArray(value);

        public static implicit operator NDArray(float value)
            => new NDArray(value);

        public static implicit operator NDArray(double value)
            => new NDArray(value);
    }
}