ARGoS 3
A parallel, multi-engine simulator for swarm robotics
lua_utility.cpp
Go to the documentation of this file.
1
7#include "lua_utility.h"
8
9#include <argos3/core/utility/configuration/argos_exception.h>
10#include <argos3/core/utility/math/angles.h>
11#include <argos3/core/utility/math/vector2.h>
12#include <argos3/core/utility/math/vector3.h>
13#include <argos3/core/utility/math/quaternion.h>
14#include <argos3/core/utility/datatypes/color.h>
15
16#include <argos3/core/wrappers/lua/lua_vector2.h>
17#include <argos3/core/wrappers/lua/lua_vector3.h>
18#include <argos3/core/wrappers/lua/lua_quaternion.h>
19
20namespace argos {
21
22 /****************************************/
23 /****************************************/
24
25 static const CRange<Real> UNIT(0.0f, 1.0f);
26
27 int LuaRNGBernoulli(lua_State* pt_state) {
28 /* Check number of parameters */
29 if(lua_gettop(pt_state) > 1) {
30 return luaL_error(pt_state, "robot.random.bernoulli() expects 0 or 1 arguments");
31 }
32 /* Get RNG instance */
33 CRandom::CRNG* pcRNG = CLuaUtility::GetDeviceInstance<CRandom::CRNG>(pt_state, "random");
34 /* Perform wanted action */
35 if(lua_gettop(pt_state) == 0) {
36 /* Return random result */
37 lua_pushboolean(pt_state, pcRNG->Bernoulli());
38 return 1;
39 }
40 else {
41 /* Check parameter */
42 luaL_checktype(pt_state, 1, LUA_TNUMBER);
43 /* Return random number */
44 lua_pushboolean(pt_state,
45 pcRNG->Bernoulli(lua_tonumber(pt_state, 1)));
46 return 1;
47 }
48 /* Can't reach this point */
49 return 0;
50 }
51
52 int LuaRNGUniform(lua_State* pt_state) {
53 /* Check number of parameters */
54 if(lua_gettop(pt_state) > 2) {
55 return luaL_error(pt_state, "robot.random.uniform() expects 0, 1, or 2 arguments");
56 }
57 /* Get RNG instance */
58 CRandom::CRNG* pcRNG = CLuaUtility::GetDeviceInstance<CRandom::CRNG>(pt_state, "random");
59 /* Perform wanted action */
60 if(lua_gettop(pt_state) == 0) {
61 /* Return a number between 0 and 1 */
62 lua_pushnumber(pt_state, pcRNG->Uniform(UNIT));
63 return 1;
64 }
65 else if(lua_gettop(pt_state) == 1) {
66 /* Check parameter */
67 luaL_checktype(pt_state, 1, LUA_TNUMBER);
68 /* Return a number between 0 and the max */
69 lua_pushnumber(pt_state,
70 pcRNG->Uniform(CRange<Real>(0,
71 lua_tonumber(pt_state, 1))));
72 return 1;
73 }
74 else {
75 /* Check parameters */
76 luaL_checktype(pt_state, 1, LUA_TNUMBER);
77 luaL_checktype(pt_state, 2, LUA_TNUMBER);
78 /* Return a number between min and max */
79 lua_pushnumber(pt_state,
80 pcRNG->Uniform(CRange<Real>(lua_tonumber(pt_state, 1),
81 lua_tonumber(pt_state, 2))));
82 return 1;
83 }
84 /* Can't reach this point */
85 return 0;
86 }
87
88 int LuaRNGUniformInt(lua_State* pt_state) {
89 /* Check number of parameters */
90 if(lua_gettop(pt_state) > 2) {
91 return luaL_error(pt_state, "robot.random.uniform_int() expects 1 or 2 arguments");
92 }
93 /* Get RNG instance */
94 CRandom::CRNG* pcRNG = CLuaUtility::GetDeviceInstance<CRandom::CRNG>(pt_state, "random");
95 /* Perform wanted action */
96 if(lua_gettop(pt_state) == 1) {
97 /* Check parameter */
98 luaL_checktype(pt_state, 1, LUA_TNUMBER);
99 /* Return a number between 0 and the max */
100 lua_pushnumber(pt_state,
101 pcRNG->Uniform(CRange<UInt32>(0,
102 Floor(lua_tonumber(pt_state, 1)))));
103 return 1;
104 }
105 else {
106 /* Check parameters */
107 luaL_checktype(pt_state, 1, LUA_TNUMBER);
108 luaL_checktype(pt_state, 2, LUA_TNUMBER);
109 /* Return a number between min and max */
110 lua_pushnumber(pt_state,
111 pcRNG->Uniform(CRange<SInt32>(Floor(lua_tonumber(pt_state, 1)),
112 Floor(lua_tonumber(pt_state, 2)))));
113 return 1;
114 }
115 /* Can't reach this point */
116 return 0;
117 }
118
119 int LuaRNGExponential(lua_State* pt_state) {
120 /* Check number of parameters */
121 if(lua_gettop(pt_state) != 1) {
122 return luaL_error(pt_state, "robot.random.exponential() expects 1 argument");
123 }
124 /* Get RNG instance */
125 CRandom::CRNG* pcRNG = CLuaUtility::GetDeviceInstance<CRandom::CRNG>(pt_state, "random");
126 /* Check parameter */
127 luaL_checktype(pt_state, 1, LUA_TNUMBER);
128 /* Return random number */
129 lua_pushnumber(pt_state,
130 pcRNG->Exponential(lua_tonumber(pt_state, 1)));
131 return 1;
132 }
133
134 int LuaRNGPoisson(lua_State* pt_state) {
135 /* Check number of parameters */
136 if(lua_gettop(pt_state) != 1) {
137 return luaL_error(pt_state, "robot.random.poisson() expects 1 argument");
138 }
139 /* Get RNG instance */
140 CRandom::CRNG* pcRNG = CLuaUtility::GetDeviceInstance<CRandom::CRNG>(pt_state, "random");
141 /* Check parameter */
142 luaL_checktype(pt_state, 1, LUA_TNUMBER);
143 /* Return random number */
144 lua_pushinteger(pt_state,
145 pcRNG->Poisson(lua_tonumber(pt_state, 1)));
146 return 1;
147 }
148
149 int LuaRNGGaussian(lua_State* pt_state) {
150 /* Check number of parameters */
151 if(lua_gettop(pt_state) != 1 && lua_gettop(pt_state) != 2) {
152 return luaL_error(pt_state, "robot.random.gaussian() expects 1 or 2 arguments");
153 }
154 /* Get RNG instance */
155 CRandom::CRNG* pcRNG = CLuaUtility::GetDeviceInstance<CRandom::CRNG>(pt_state, "random");
156 /* Perform wanted action */
157 if(lua_gettop(pt_state) == 1) {
158 /* Check parameter */
159 luaL_checktype(pt_state, 1, LUA_TNUMBER);
160 /* Return random number */
161 lua_pushnumber(pt_state, pcRNG->Gaussian(lua_tonumber(pt_state, 1)));
162 return 1;
163 }
164 else {
165 /* Check parameters */
166 luaL_checktype(pt_state, 1, LUA_TNUMBER);
167 luaL_checktype(pt_state, 2, LUA_TNUMBER);
168 /* Return random number */
169 lua_pushnumber(pt_state,
170 pcRNG->Gaussian(lua_tonumber(pt_state, 1),
171 lua_tonumber(pt_state, 2)));
172 return 1;
173 }
174 /* Can't reach this point */
175 return 0;
176 }
177
178 /****************************************/
179 /****************************************/
180
181 bool CLuaUtility::LoadScript(lua_State* pt_state,
182 const std::string& str_filename) {
183 if(luaL_loadfile(pt_state, str_filename.c_str())) {
184 LOGERR << "[FATAL] Error loading \"" << str_filename
185 << "\"" << std::endl;
186 return false;
187 }
188 if(lua_pcall(pt_state, 0, 0, 0)) {
189 LOGERR << "[FATAL] Error executing \"" << str_filename
190 << "\"" << std::endl;
191 LOGERR << "[FATAL] " << lua_tostring(pt_state, -1)
192 << std::endl;
193 return false;
194 }
195 return true;
196 }
197
198 /****************************************/
199 /****************************************/
200
201 bool CLuaUtility::CallLuaFunction(lua_State* pt_state,
202 const std::string& str_function) {
203 lua_getglobal(pt_state, str_function.c_str());
204 if(lua_pcall(pt_state, 0, 0, 0)) {
205 LOGERR << "[FATAL] Error calling \"" << str_function
206 << "\"" << std::endl;
207 LOGERR << "[FATAL] " << lua_tostring(pt_state, -1)
208 << std::endl;
209 return false;
210 }
211 return true;
212 }
213
214 /****************************************/
215 /****************************************/
216
217 void PrintStackEntry(CARGoSLog& c_log, lua_State* pt_state, SInt32 n_index) {
218 switch(lua_type(pt_state, n_index)) {
219 case LUA_TBOOLEAN: c_log << lua_toboolean(pt_state, n_index); break;
220 case LUA_TNUMBER: c_log << lua_tonumber(pt_state, n_index); break;
221 case LUA_TSTRING: c_log << lua_tostring(pt_state, n_index); break;
222 default: c_log << lua_topointer(pt_state, n_index); break;
223 }
224 }
225
226 /****************************************/
227 /****************************************/
228
229 void RecursivePrintGlobals(CARGoSLog& c_log,
230 lua_State* pt_state,
231 size_t un_depth) {
232 for(size_t i = 0; i < un_depth; ++i) {
233 c_log << " ";
234 }
235 PrintStackEntry(c_log, pt_state, -2);
236 c_log << " [" << lua_typename(pt_state, lua_type(pt_state, -1)) << "] ";
237 if(lua_istable(pt_state, -1)) {
238 c_log << std::endl;
239 lua_pushnil(pt_state);
240 while(lua_next(pt_state, -2)) {
241 if(lua_type(pt_state, -1) != LUA_TFUNCTION &&
242 (lua_type(pt_state, -2) != LUA_TSTRING ||
243 (std::string(lua_tostring(pt_state, -2)) != "_G" &&
244 std::string(lua_tostring(pt_state, -2)) != "_VERSION" &&
245 std::string(lua_tostring(pt_state, -2)) != "package" &&
246 std::string(lua_tostring(pt_state, -2)) != "string" &&
247 std::string(lua_tostring(pt_state, -2)) != "os" &&
248 std::string(lua_tostring(pt_state, -2)) != "io" &&
249 std::string(lua_tostring(pt_state, -2)) != "math" &&
250 std::string(lua_tostring(pt_state, -2)) != "debug" &&
251 std::string(lua_tostring(pt_state, -2)) != "coroutine" &&
252 std::string(lua_tostring(pt_state, -2)) != "table"))) {
253 RecursivePrintGlobals(c_log, pt_state, un_depth+1);
254 }
255 lua_pop(pt_state, 1);
256 }
257 }
258 else {
259 PrintStackEntry(c_log, pt_state, -1);
260 c_log << std::endl;
261 }
262 }
263
264 /****************************************/
265 /****************************************/
266
267 void CLuaUtility::PrintGlobals(CARGoSLog& c_log,
268 lua_State* pt_state) {
269 c_log << "*** LUA GLOBALS START ***" << std::endl;
270 lua_getglobal(pt_state, "_G");
271 RecursivePrintGlobals(c_log, pt_state, 0);
272 lua_pop(pt_state, 1);
273 c_log << "*** LUA GLOBALS END ***" << std::endl;
274#ifdef ARGOS_THREADSAFE_LOG
275 c_log.Flush();
276#endif
277 }
278
279 /****************************************/
280 /****************************************/
281
282 void CLuaUtility::PrintStack(CARGoSLog& c_log,
283 lua_State* pt_state) {
284 c_log << "*** LUA STACK START ***" << std::endl;
285 size_t unTop = lua_gettop(pt_state);
286 c_log << "Elements in stack: " << unTop << std::endl;
287 for(size_t i = unTop; i > 0; --i) {
288 c_log << "#" << i << " [" << lua_typename(pt_state, lua_type(pt_state, i)) << "] ";
289 PrintStackEntry(c_log, pt_state, i);
290 c_log << std::endl;
291 }
292 c_log << "*** LUA STACK END ***" << std::endl;
293#ifdef ARGOS_THREADSAFE_LOG
294 c_log.Flush();
295#endif
296 }
297
298 /****************************************/
299 /****************************************/
300
301 void CLuaUtility::RegisterLoggerWrapper(lua_State* pt_state) {
302 lua_register(pt_state, "log", LOGWrapper);
303 lua_register(pt_state, "logerr", LOGERRWrapper);
304 }
305
306 /****************************************/
307 /****************************************/
308
309 void CLuaUtility::RegisterRNG(lua_State* pt_state,
310 CRandom::CRNG* pc_rng) {
311 pc_rng->Reset();
312 OpenRobotStateTable(pt_state, "random");
313 AddToTable(pt_state, "_instance", pc_rng);
314 AddToTable(pt_state, "bernoulli", &LuaRNGBernoulli);
315 AddToTable(pt_state, "uniform", &LuaRNGUniform);
316 AddToTable(pt_state, "uniform_int", &LuaRNGUniformInt);
317 AddToTable(pt_state, "exponential", &LuaRNGExponential);
318 AddToTable(pt_state, "poisson", &LuaRNGPoisson);
319 AddToTable(pt_state, "gaussian", &LuaRNGGaussian);
320 CloseRobotStateTable(pt_state);
321 }
322
323 /****************************************/
324 /****************************************/
325
326 void CLuaUtility::OpenRobotStateTable(lua_State* pt_state,
327 const std::string& str_key) {
328 lua_pushstring(pt_state, str_key.c_str());
329 lua_rawget(pt_state, -2);
330 if(lua_isnil(pt_state, -1)) {
331 lua_pop(pt_state, 1);
332 StartTable(pt_state, str_key);
333 EndTable(pt_state);
334 lua_pushstring(pt_state, str_key.c_str());
335 lua_rawget(pt_state, -2);
336 }
337 }
338
339 /****************************************/
340 /****************************************/
341
342 void CLuaUtility::CloseRobotStateTable(lua_State* pt_state) {
343 lua_pop(pt_state, 1);
344 }
345
346 /****************************************/
347 /****************************************/
348
349 void CLuaUtility::StartTable(lua_State* pt_state,
350 const std::string& str_key) {
351 lua_pushstring(pt_state, str_key.c_str());
352 lua_newtable (pt_state);
353 }
354
355 /****************************************/
356 /****************************************/
357
358 void CLuaUtility::StartTable(lua_State* pt_state,
359 int n_key) {
360 lua_pushnumber(pt_state, n_key);
361 lua_newtable (pt_state);
362 }
363
364 /****************************************/
365 /****************************************/
366
367 void CLuaUtility::EndTable(lua_State* pt_state) {
368 lua_settable(pt_state, -3);
369 }
370
371 /****************************************/
372 /****************************************/
373
374 void CLuaUtility::SetMetatable(lua_State* pt_state,
375 const std::string& str_key) {
376 luaL_getmetatable(pt_state, str_key.c_str());
377 lua_setmetatable(pt_state, -2);
378 }
379
380 /****************************************/
381 /****************************************/
382
383 void CLuaUtility::AddToTable(lua_State* pt_state,
384 const std::string& str_key,
385 void* pt_data) {
386 lua_pushstring (pt_state, str_key.c_str());
387 lua_pushlightuserdata(pt_state, pt_data );
388 lua_settable (pt_state, -3 );
389 }
390
391 /****************************************/
392 /****************************************/
393
394 void CLuaUtility::AddToTable(lua_State* pt_state,
395 const std::string& str_key,
396 lua_CFunction t_data) {
397 lua_pushstring (pt_state, str_key.c_str());
398 lua_pushcfunction(pt_state, t_data );
399 lua_settable (pt_state, -3 );
400 }
401
402 /****************************************/
403 /****************************************/
404
405 void CLuaUtility::AddToTable(lua_State* pt_state,
406 const std::string& str_key,
407 const std::string& str_data){
408 lua_pushstring(pt_state, str_key.c_str() );
409 lua_pushstring(pt_state, str_data.c_str());
410 lua_settable (pt_state, -3 );
411 }
412
413 /****************************************/
414 /****************************************/
415
416 void CLuaUtility::AddToTable(lua_State* pt_state,
417 int n_key,
418 const std::string& str_data){
419 lua_pushnumber(pt_state, n_key );
420 lua_pushstring(pt_state, str_data.c_str());
421 lua_settable (pt_state, -3 );
422 }
423
424 /****************************************/
425 /****************************************/
426
427 void CLuaUtility::AddToTable(lua_State* pt_state,
428 const std::string& str_key,
429 Real f_data) {
430 lua_pushstring(pt_state, str_key.c_str());
431 lua_pushnumber(pt_state, f_data );
432 lua_settable (pt_state, -3 );
433 }
434
435 /****************************************/
436 /****************************************/
437
438 void CLuaUtility::AddToTable(lua_State* pt_state,
439 int n_key,
440 Real f_data) {
441 lua_pushnumber(pt_state, n_key );
442 lua_pushnumber(pt_state, f_data);
443 lua_settable (pt_state, -3 );
444 }
445
446 /****************************************/
447 /****************************************/
448
449 void CLuaUtility::AddToTable(lua_State* pt_state,
450 const std::string& str_key,
451 const CRadians& c_data) {
452 lua_pushstring(pt_state, str_key.c_str() );
453 lua_pushnumber(pt_state, c_data.GetValue());
454 lua_settable (pt_state, -3 );
455 }
456
457 /****************************************/
458 /****************************************/
459
460 void CLuaUtility::AddToTable(lua_State* pt_state,
461 int n_key,
462 const CRadians& c_data) {
463 lua_pushnumber(pt_state, n_key );
464 lua_pushnumber(pt_state, c_data.GetValue());
465 lua_settable (pt_state, -3 );
466 }
467
468 /****************************************/
469 /****************************************/
470
471 void CLuaUtility::AddToTable(lua_State* pt_state,
472 const std::string& str_key,
473 const CVector2& c_data) {
474 lua_pushstring (pt_state, str_key.c_str());
475 CLuaVector2::PushVector2(pt_state, c_data);
476 lua_settable (pt_state, -3);
477 }
478
479 /****************************************/
480 /****************************************/
481
482 void CLuaUtility::AddToTable(lua_State* pt_state,
483 int n_key,
484 const CVector2& c_data) {
485 lua_pushnumber (pt_state, n_key);
486 CLuaVector2::PushVector2(pt_state, c_data);
487 lua_settable (pt_state, -3);
488 }
489
490 /****************************************/
491 /****************************************/
492
493 void CLuaUtility::AddToTable(lua_State* pt_state,
494 const std::string& str_key,
495 const CVector3& c_data) {
496 lua_pushstring (pt_state, str_key.c_str());
497 CLuaVector3::PushVector3(pt_state, c_data);
498 lua_settable (pt_state, -3);
499 }
500
501 /****************************************/
502 /****************************************/
503
504 void CLuaUtility::AddToTable(lua_State* pt_state,
505 int n_key,
506 const CVector3& c_data) {
507 lua_pushnumber (pt_state, n_key);
508 CLuaVector3::PushVector3(pt_state, c_data);
509 lua_settable (pt_state, -3);
510 }
511
512
513 /****************************************/
514 /****************************************/
515
516 void CLuaUtility::AddToTable(lua_State* pt_state,
517 const std::string& str_key,
518 const CQuaternion& c_data) {
519 lua_pushstring (pt_state, str_key.c_str());
520 CLuaQuaternion::PushQuaternion(pt_state, c_data);
521 lua_settable (pt_state, -3);
522 }
523
524 /****************************************/
525 /****************************************/
526
527 void CLuaUtility::AddToTable(lua_State* pt_state,
528 int n_key,
529 const CQuaternion& c_data) {
530 lua_pushnumber (pt_state, n_key);
531 CLuaQuaternion::PushQuaternion(pt_state, c_data);
532 lua_settable (pt_state, -3);
533 }
534
535 /****************************************/
536 /****************************************/
537
538 void CLuaUtility::AddToTable(lua_State* pt_state,
539 const std::string& str_key,
540 const CColor& c_data) {
541 StartTable(pt_state, str_key );
542 AddToTable(pt_state, "red", c_data.GetRed() );
543 AddToTable(pt_state, "green", c_data.GetGreen());
544 AddToTable(pt_state, "blue", c_data.GetBlue() );
545 EndTable (pt_state );
546 }
547
548 /****************************************/
549 /****************************************/
550
551 void CLuaUtility::AddToTable(lua_State* pt_state,
552 int n_key,
553 const CColor& c_data) {
554 StartTable(pt_state, n_key );
555 AddToTable(pt_state, "red", c_data.GetRed() );
556 AddToTable(pt_state, "green", c_data.GetGreen());
557 AddToTable(pt_state, "blue", c_data.GetBlue() );
558 EndTable (pt_state );
559 }
560
561 /****************************************/
562 /****************************************/
563
564 int CLuaUtility::LOGWrapper(lua_State* pt_state) {
565 return LoggerWrapper(LOG, pt_state);
566 }
567
568 /****************************************/
569 /****************************************/
570
571 int CLuaUtility::LOGERRWrapper(lua_State* pt_state) {
572 return LoggerWrapper(LOGERR, pt_state);
573 }
574
575 /****************************************/
576 /****************************************/
577
578 int CLuaUtility::LoggerWrapper(CARGoSLog& c_log,
579 lua_State* pt_state) {
580 /* Get number of arguments */
581 UInt32 unArgc = lua_gettop(pt_state);
582 /* Send arguments to log one by one */
583 UInt32 unType;
584 for(UInt32 i = 1; i <= unArgc; ++i) {
585 unType = lua_type(pt_state, i);
586 switch(unType) {
587 case LUA_TBOOLEAN: c_log << lua_toboolean(pt_state, i); break;
588 case LUA_TNUMBER: c_log << lua_tonumber (pt_state, i); break;
589 case LUA_TSTRING: c_log << lua_tostring (pt_state, i); break;
590 default: c_log << lua_typename (pt_state, unType); break;
591 }
592 }
593 c_log << std::endl;
594 /* No result is calculated */
595 return 0;
596 }
597
598 /****************************************/
599 /****************************************/
600
601}
SInt32
signed int SInt32
32-bit signed integer.
Definition datatypes.h:93
UInt32
unsigned int UInt32
32-bit unsigned integer.
Definition datatypes.h:97
Real
float Real
Collects all ARGoS code.
Definition datatypes.h:39
argos
The namespace containing all the ARGoS related code.
Definition ci_actuator.h:12
argos::LOGERR
CARGoSLog LOGERR(std::cerr, SLogColor(ARGOS_LOG_ATTRIBUTE_BRIGHT, ARGOS_LOG_COLOR_RED))
Definition argos_log.h:180
argos::RecursivePrintGlobals
void RecursivePrintGlobals(CARGoSLog &c_log, lua_State *pt_state, size_t un_depth)
Definition lua_utility.cpp:229
argos::LuaRNGBernoulli
int LuaRNGBernoulli(lua_State *pt_state)
Definition lua_utility.cpp:27
argos::LuaRNGPoisson
int LuaRNGPoisson(lua_State *pt_state)
Definition lua_utility.cpp:134
argos::LuaRNGUniformInt
int LuaRNGUniformInt(lua_State *pt_state)
Definition lua_utility.cpp:88
argos::LuaRNGExponential
int LuaRNGExponential(lua_State *pt_state)
Definition lua_utility.cpp:119
argos::LOG
CARGoSLog LOG(std::cout, SLogColor(ARGOS_LOG_ATTRIBUTE_BRIGHT, ARGOS_LOG_COLOR_GREEN))
Definition argos_log.h:179
argos::LuaRNGUniform
int LuaRNGUniform(lua_State *pt_state)
Definition lua_utility.cpp:52
argos::Floor
SInt32 Floor(Real f_value)
Rounds the passed floating-point value to the closest lower integer.
Definition general.h:140
argos::PrintStackEntry
void PrintStackEntry(CARGoSLog &c_log, lua_State *pt_state, SInt32 n_index)
Definition lua_utility.cpp:217
argos::LuaRNGGaussian
int LuaRNGGaussian(lua_State *pt_state)
Definition lua_utility.cpp:149
argos::CColor
The basic color type.
Definition color.h:25
argos::CColor::GetBlue
UInt8 GetBlue() const
Returns the blue channel of the color.
Definition color.h:101
argos::CColor::GetGreen
UInt8 GetGreen() const
Returns the green channel of the color.
Definition color.h:90
argos::CColor::GetRed
UInt8 GetRed() const
Returns the red channel of the color.
Definition color.h:79
argos::CRadians
It defines the basic type CRadians, used to store an angle value in radians.
Definition angles.h:42
argos::CRadians::GetValue
Real GetValue() const
Returns the value in radians.
Definition angles.h:111
argos::CRandom::CRNG
The RNG.
Definition rng.h:90
argos::CRandom::CRNG::Poisson
UInt32 Poisson(Real f_mean)
Returns a random value from a Poisson distribution.
Definition rng.cpp:131
argos::CRandom::CRNG::Bernoulli
bool Bernoulli(Real f_true=0.5)
Returns a random value from a Bernoulli distribution.
Definition rng.cpp:80
argos::CRandom::CRNG::Reset
void Reset()
Reset the RNG.
Definition rng.cpp:68
argos::CRandom::CRNG::Exponential
Real Exponential(Real f_mean)
Returns a random value from an exponential distribution.
Definition rng.cpp:123
argos::CRandom::CRNG::Gaussian
Real Gaussian(Real f_std_dev, Real f_mean=0.0f)
Returns a random value from a Gaussian distribution.
Definition rng.cpp:152
argos::CRandom::CRNG::Uniform
CRadians Uniform(const CRange< CRadians > &c_range)
Returns a random value from a uniform distribution.
Definition rng.cpp:87
argos::CVector2
A 2D vector class.
Definition vector2.h:27
argos::CVector3
A 3D vector class.
Definition vector3.h:31
argos::CLuaQuaternion::PushQuaternion
static void PushQuaternion(lua_State *pt_state, TArguments &&... t_arguments)
Definition lua_quaternion.h:37
argos::CLuaUtility::EndTable
static void EndTable(lua_State *pt_state)
Adds a table to the Lua stack.
Definition lua_utility.cpp:367
argos::CLuaUtility::AddToTable
static void AddToTable(lua_State *pt_state, const std::string &str_key, void *pt_data)
Adds a pointer to a chunk of data with the given string key to the table located at the top of the st...
Definition lua_utility.cpp:383
argos::CLuaUtility::CallLuaFunction
static bool CallLuaFunction(lua_State *pt_state, const std::string &str_function)
Calls a parameter-less function in the Lua script.
Definition lua_utility.cpp:201
argos::CLuaUtility::SetMetatable
static void SetMetatable(lua_State *pt_state, const std::string &str_key)
Sets the metatable with the given string key to the table located at the top of the stack.
Definition lua_utility.cpp:374
argos::CLuaUtility::LoadScript
static bool LoadScript(lua_State *pt_state, const std::string &str_filename)
Loads the given Lua script.
Definition lua_utility.cpp:181
argos::CLuaUtility::StartTable
static void StartTable(lua_State *pt_state, const std::string &str_key)
Adds a table with the given string key to the table located at the top of the stack.
Definition lua_utility.cpp:349
argos::CLuaUtility::RegisterLoggerWrapper
static void RegisterLoggerWrapper(lua_State *pt_state)
Registers LOG and LOGERR in the Lua state.
Definition lua_utility.cpp:301
argos::CLuaUtility::OpenRobotStateTable
static void OpenRobotStateTable(lua_State *pt_state, const std::string &str_key)
Opens a table in the robot state, creating it if it does not exist.
Definition lua_utility.cpp:326
argos::CLuaUtility::CloseRobotStateTable
static void CloseRobotStateTable(lua_State *pt_state)
Closes a table in the robot state.
Definition lua_utility.cpp:342
argos::CLuaUtility::PrintStack
static void PrintStack(CARGoSLog &c_log, lua_State *pt_state)
Prints the Lua stack on the specified log.
Definition lua_utility.cpp:282
argos::CLuaUtility::RegisterRNG
static void RegisterRNG(lua_State *pt_state, CRandom::CRNG *pc_rng)
Registers the given random number generator in the Lua state.
Definition lua_utility.cpp:309
argos::CLuaUtility::GetDeviceInstance
static T * GetDeviceInstance(lua_State *pt_state, const std::string &str_key)
Returns a pointer to the instance to the wanted device.
Definition lua_utility.h:380
argos::CLuaUtility::PrintGlobals
static void PrintGlobals(CARGoSLog &c_log, lua_State *pt_state)
Prints the global Lua symbols on the specified log.
Definition lua_utility.cpp:267
argos::CLuaVector2::PushVector2
static void PushVector2(lua_State *pt_state, TArguments &&... t_arguments)
Definition lua_vector2.h:37
argos::CLuaVector3::PushVector3
static void PushVector3(lua_State *pt_state, TArguments &&... t_arguments)
Definition lua_vector3.h:37