source: trunk/HeuristicLab.ExtLibs/HeuristicLab.NativeInterpreter/0.1/NativeInterpreter-0.1/src/interpreter.h @ 16274

Last change on this file since 16274 was 16274, checked in by bburlacu, 10 months ago

#2958: Update dll files and C++ source code to the latest version.

File size: 7.4 KB
Line 
1#ifndef NATIVE_TREE_INTERPRETER_CLANG_H
2#define NATIVE_TREE_INTERPRETER_CLANG_H
3
4#include "vector_operations.h"
5#include "instruction.h"
6
7inline double evaluate(instruction *code, int len, int row) noexcept
8{
9    for (int i = len - 1; i >= 0; --i)
10    {
11        instruction &in = code[i];
12        switch (in.opcode)
13        {
14            case OpCodes::Var:
15                {
16                    in.value = in.weight * in.data[row];
17                    break;
18                }
19            case OpCodes::Add:
20                {
21                    in.value = code[in.childIndex].value;
22                    for (int j = 1; j < in.narg; ++j)
23                    {
24                        in.value += code[in.childIndex + j].value;
25                    }
26                    break;
27                }
28            case OpCodes::Sub:
29                {
30                    in.value = code[in.childIndex].value;
31                    for (int j = 1; j < in.narg; ++j)
32                    {
33                        in.value -= code[in.childIndex + j].value;
34                    }
35                    if (in.narg == 1)
36                    {
37                        in.value = -in.value;
38                    }
39                    break;
40                }
41            case OpCodes::Mul:
42                {
43                    in.value = code[in.childIndex].value;
44                    for (int j = 1; j < in.narg; ++j)
45                    {
46                        in.value *= code[in.childIndex + j].value;
47                    }
48                    break;
49                }
50            case OpCodes::Div:
51                {
52                    in.value = code[in.childIndex].value;
53                    for (int j = 1; j < in.narg; ++j)
54                    {
55                        in.value /= code[in.childIndex + j].value;
56                    }
57                    if (in.narg == 1)
58                    {
59                        in.value = 1 / in.value;
60                    }
61                    break;
62                }
63            case OpCodes::Exp:
64                {
65                    in.value = std::exp(code[in.childIndex].value);
66                    break;
67                }
68            case OpCodes::Log:
69                {
70                    in.value = std::log(code[in.childIndex].value);
71                    break;
72                }
73            case OpCodes::Sin:
74                {
75                    in.value = std::sin(code[in.childIndex].value);
76                    break;
77                }
78            case OpCodes::Cos:
79                {
80                    in.value = std::cos(code[in.childIndex].value);
81                    break;
82                }
83            case OpCodes::Tan:
84                {
85                    in.value = std::tan(code[in.childIndex].value);
86                    break;
87                }
88            case OpCodes::Power:
89                {
90                    double x = code[in.childIndex].value;
91                    double y = std::round(code[in.childIndex + 1].value);
92                    in.value = std::pow(x, y);
93                    break;
94                }
95            case OpCodes::Root:
96                {
97                    double x = code[in.childIndex].value;
98                    double y = std::round(code[in.childIndex + 1].value);
99                    in.value = std::pow(x, 1 / y);
100                    break;
101                }
102            case OpCodes::Sqrt:
103                {
104                    in.value = std::sqrt(code[in.childIndex].value);
105                    break;
106                }
107        }
108    }
109    return code[0].value;
110}
111
112inline void load_data(instruction &in, int* __restrict rows, int rowIndex, int batchSize) noexcept
113{
114    for (int i = 0; i < batchSize; ++i)
115    {
116        auto row = rows[rowIndex + i];
117        in.buf[i] = in.weight * in.data[row];
118    }
119}
120
121inline void evaluate(instruction* code, int len, int* __restrict rows, int rowIndex, int batchSize) noexcept
122{
123    for (int i = len - 1; i >= 0; --i)
124    {
125        instruction &in = code[i];
126        switch (in.opcode)
127        {
128            case OpCodes::Var:
129                {
130                    load_data(in, rows, rowIndex, batchSize); // buffer data
131                    break;
132                }
133            case OpCodes::Add:
134                {
135                    load(in.buf, code[in.childIndex].buf);
136                    for (int j = 1; j < in.narg; ++j)
137                    {
138                        add(in.buf, code[in.childIndex + j].buf);
139                    }
140                    break;
141                }
142            case OpCodes::Sub:
143                {
144                    if (in.narg == 1)
145                    {
146                        neg(in.buf, code[in.childIndex].buf);
147                        break;
148                    }
149                    else
150                    {
151                        load(in.buf, code[in.childIndex].buf);
152                        for (int j = 1; j < in.narg; ++j)
153                        {
154                            sub(in.buf, code[in.childIndex + j].buf);
155                        }
156                    }
157                    break;
158                }
159            case OpCodes::Mul:
160                {
161                    load(in.buf, code[in.childIndex].buf);
162                    for (int j = 1; j < in.narg; ++j)
163                    {
164                        mul(in.buf, code[in.childIndex + j].buf);
165                    }
166                    break;
167                }
168            case OpCodes::Div:
169                {
170                    if (in.narg == 1)
171                    {
172                        inv(in.buf, code[in.childIndex].buf);
173                        break;
174                    }
175                    else
176                    {
177                        load(in.buf, code[in.childIndex].buf);
178                        for (int j = 1; j < in.narg; ++j)
179                        {
180                            div(in.buf, code[in.childIndex + j].buf);
181                        }
182                    }
183                    break;
184                }
185            case OpCodes::Sin:
186                {
187                    sin(in.buf, code[in.childIndex].buf);
188                    break;
189                }
190            case OpCodes::Cos:
191                {
192                    cos(in.buf, code[in.childIndex].buf);
193                    break;
194                }
195            case OpCodes::Tan:
196                {
197                    tan(in.buf, code[in.childIndex].buf);
198                    break;
199                }
200            case OpCodes::Log:
201                {
202                    log(in.buf, code[in.childIndex].buf);
203                    break;
204                }
205            case OpCodes::Exp:
206                {
207                    exp(in.buf, code[in.childIndex].buf);
208                    break;
209                }
210            case OpCodes::Power:
211                {
212                    load(in.buf, code[in.childIndex].buf);
213                    pow(in.buf, code[in.childIndex + 1].buf);
214                    break;
215                }
216            case OpCodes::Root:
217                {
218                    load(in.buf, code[in.childIndex].buf);
219                    root(in.buf, code[in.childIndex + 1].buf);
220                    break;
221                }
222            case OpCodes::Square:
223                {
224                    square(in.buf, code[in.childIndex].buf);
225                    break;
226                }
227        }
228    }
229}
230
231#endif
Note: See TracBrowser for help on using the repository browser.