PEBL 2.2
Psychology Experiment Building Language - Cross-platform psychological experiment development system
Functions | Variables
PEBLMath Namespace Reference

Functions

Variant Recurse (Variant v, Variant(*)(Variant))
 
Variant Recurse2 (Variant v, Variant(*)(Variant), Variant argument)
 
Variant Log10 (Variant v)
 
Variant Log2 (Variant v)
 
Variant Ln (Variant v)
 
Variant LogN (Variant v)
 
Variant Exp (Variant v)
 
Variant Pow (Variant v)
 
Variant Sqrt (Variant v)
 
Variant NthRoot (Variant v)
 
Variant Tan (Variant v)
 
Variant Sin (Variant v)
 Sin takes one parameter.
 
Variant Cos (Variant v)
 
Variant ATan (Variant v)
 
Variant ASin (Variant v)
 
Variant ACos (Variant v)
 
Variant DegToRad (Variant v)
 
Variant RadToDeg (Variant v)
 
Variant Round (Variant v)
 
Variant Floor (Variant v)
 
Variant Ceiling (Variant v)
 
Variant AbsFloor (Variant v)
 
Variant Mod (Variant v)
 
Variant Div (Variant v)
 
Variant ToInt (Variant v)
 
Variant ToFloat (Variant v)
 
Variant ToNumber (Variant v)
 
Variant ToString (Variant v)
 
Variant Sign (Variant v)
 
Variant Abs (Variant v)
 
Variant RandomizeTimer (Variant v)
 
Variant SeedRNG (Variant v)
 
Variant Random (Variant v)
 
Variant RandomDiscrete (Variant v)
 
Variant RandomUniform (Variant v)
 
Variant RandomNormal (Variant v)
 
Variant RandomExponential (Variant v)
 
Variant RandomLogistic (Variant v)
 
Variant RandomLogNormal (Variant v)
 
Variant RandomBinomial (Variant v)
 
Variant RandomBernoulli (Variant v)
 

Variables

PEBL_Function_Type FunctionTable []
 

Function Documentation

◆ Abs()

Variant PEBLMath::Abs ( Variant  v)

Definition at line 852 of file PEBLMath.cpp.

853{
854
855 PList * plist = v.GetComplexData()->GetList();
856
857 Variant v1 = plist->First();
858 if(v1.IsNumber())
859 {
860 return Variant((pDouble)fabsl(v1.GetFloat()));
861 }
862 else if(v1.GetComplexData()->IsList())
863 {
864 return Recurse(v1, Abs);
865
866 }
867 else
868 {
869 PError::SignalFatalError("Non-numeric argument in Function [AbsFloor]");
870 return 0;
871 }
872
873}
pDouble
#define pDouble
Definition Defs.h:7
PComplexData::GetList
PList * GetList() const
Definition PComplexData.cpp:339
PComplexData::IsList
bool IsList() const
Definition PComplexData.cpp:206
PList
Definition PList.h:45
PList::First
Variant First()
Definition PList.cpp:169
Variant::GetComplexData
PComplexData * GetComplexData() const
Definition Variant.cpp:1299
Variant::GetFloat
pDouble GetFloat() const
Definition Variant.cpp:1025
Variant::IsNumber
bool IsNumber() const
This tests whether the Variant is a number (i.e., a float or an integer.)
Definition Variant.cpp:930
PError::SignalFatalError
void SignalFatalError(const std::string &message)

References Abs(), PList::First(), Variant::GetComplexData(), Variant::GetFloat(), PComplexData::GetList(), PComplexData::IsList(), Variant::IsNumber(), pDouble, Recurse(), and PError::SignalFatalError().

Referenced by Abs().

◆ AbsFloor()

Variant PEBLMath::AbsFloor ( Variant  v)

Definition at line 708 of file PEBLMath.cpp.

709{
710
711 PList * plist = v.GetComplexData()->GetList();
712 Variant v1 = plist->First();
713 if(v1.IsNumber())
714 {
715 return Variant(PEBLUtility::Truncate(v1.GetFloat()));
716 }
717 else if(v1.GetComplexData()->IsList())
718 {
719 return Recurse(v1, AbsFloor);
720
721 }
722 else
723 {
724 PError::SignalFatalError("Non-numeric argument in [AbsFloor]");
725 return 0;
726 }
727
728}
PEBLUtility::Truncate
pInt Truncate(pDouble val)
Definition PEBLUtility.cpp:613

References AbsFloor(), PList::First(), Variant::GetComplexData(), Variant::GetFloat(), PComplexData::GetList(), PComplexData::IsList(), Variant::IsNumber(), Recurse(), PError::SignalFatalError(), and PEBLUtility::Truncate().

Referenced by AbsFloor().

◆ ACos()

Variant PEBLMath::ACos ( Variant  v)

Definition at line 546 of file PEBLMath.cpp.

547{
548
549 PList * plist = v.GetComplexData()->GetList();
550
551
552 Variant v1 = plist->First();
553 if(v1.IsNumber())
554 {
555 // return Variant((pDouble)acosl(v1.GetFloat()));
556 return Variant((pDouble)acos(v1.GetFloat()));
557 }
558 else if(v1.GetComplexData()->IsList())
559 {
560 return Recurse(v1, ACos);
561
562 }
563 else
564 {
565 PError::SignalFatalError("Non-numeric argument in [ACos]");
566 return 0;
567 }
568}

References ACos(), PList::First(), Variant::GetComplexData(), Variant::GetFloat(), PComplexData::GetList(), PComplexData::IsList(), Variant::IsNumber(), pDouble, Recurse(), and PError::SignalFatalError().

Referenced by ACos(), and main().

◆ ASin()

Variant PEBLMath::ASin ( Variant  v)

Definition at line 522 of file PEBLMath.cpp.

523{
524
525 PList * plist = v.GetComplexData()->GetList();
526
527
528 Variant v1 = plist->First();
529 if(v1.IsNumber())
530 {
531 return Variant((pDouble)asin(v1.GetFloat()));
532 //return Variant((pDouble)asinl(v1.GetFloat()));
533 }
534 else if(v1.GetComplexData()->IsList())
535 {
536 return Recurse(v1, ASin);
537
538 }
539 else
540 {
541 PError::SignalFatalError("Non-numeric argument in [ASin]");
542 return 0;
543 }
544}

References ASin(), PList::First(), Variant::GetComplexData(), Variant::GetFloat(), PComplexData::GetList(), PComplexData::IsList(), Variant::IsNumber(), pDouble, Recurse(), and PError::SignalFatalError().

Referenced by ASin(), and main().

◆ ATan()

Variant PEBLMath::ATan ( Variant  v)

Definition at line 498 of file PEBLMath.cpp.

499{
500
501 PList * plist = v.GetComplexData()->GetList();
502
503 Variant v1 = plist->First();
504 if(v1.IsNumber())
505 {
506
507 return Variant((pDouble)atan(v1.GetFloat()));
508 }
509 else if(v1.GetComplexData()->IsList())
510 {
511 return Recurse(v1, ATan);
512
513 }
514 else
515 {
516
517 PError::SignalFatalError("Non-numeric argument in [ATan]");
518 return 0;
519 }
520}

References ATan(), PList::First(), Variant::GetComplexData(), Variant::GetFloat(), PComplexData::GetList(), PComplexData::IsList(), Variant::IsNumber(), pDouble, Recurse(), and PError::SignalFatalError().

Referenced by ATan(), and main().

◆ Ceiling()

Variant PEBLMath::Ceiling ( Variant  v)

Definition at line 686 of file PEBLMath.cpp.

687{
688
689 PList * plist = v.GetComplexData()->GetList();
690 Variant v1 = plist->First();
691 if(v1.IsNumber())
692 {
693 //return Variant((pInt)(ceill(v1.GetFloat())));
694 return Variant((pInt)(ceil(v1.GetFloat())));
695 }
696 else if(v1.GetComplexData()->IsList())
697 {
698 return Recurse(v1, Ceiling);
699
700 }
701 else
702 {
703 PError::SignalFatalError("Non-numeric argument in [Ceiling]");
704 return 0;
705 }
706}
pInt
#define pInt
Definition Defs.h:8

References Ceiling(), PList::First(), Variant::GetComplexData(), Variant::GetFloat(), PComplexData::GetList(), PComplexData::IsList(), Variant::IsNumber(), pInt, Recurse(), and PError::SignalFatalError().

Referenced by Ceiling().

◆ Cos()

Variant PEBLMath::Cos ( Variant  v)

Definition at line 473 of file PEBLMath.cpp.

474{
475
476
477 PList * plist = v.GetComplexData()->GetList();
478
479 Variant v1 = plist->First();
480 if(v1.IsNumber())
481 {
482 //return Variant((pDouble)cosl(v1.GetFloat()));
483 return Variant((pDouble)cos(v1.GetFloat()));
484 }
485 else if(v1.GetComplexData()->IsList())
486 {
487 return Recurse(v1, Cos);
488 }
489 else
490 {
491
492 PError::SignalFatalError("Non-numeric argument in [Cos]");
493 return 0;
494 }
495}

References Cos(), PList::First(), Variant::GetComplexData(), Variant::GetFloat(), PComplexData::GetList(), PComplexData::IsList(), Variant::IsNumber(), pDouble, Recurse(), and PError::SignalFatalError().

Referenced by Cos(), and main().

◆ DegToRad()

Variant PEBLMath::DegToRad ( Variant  v)

Definition at line 573 of file PEBLMath.cpp.

574{
575
576 PList * plist = v.GetComplexData()->GetList();
577
578
579 Variant v1 = plist->First(); //plist->PopFront();
580
581 if(v1.IsNumber())
582 {
583 return Variant((pDouble)(v1.GetFloat() * PI / 180));
584 }
585 else if(v1.GetComplexData()->IsList())
586 {
587 return Recurse(v1, DegToRad);
588
589 }
590 else
591 {
592 PError::SignalFatalError("Non-numeric argument in [DegToRad]");
593 return 0;
594 }
595
596
597}
PI
#define PI
Definition PEBLMath.cpp:52

References DegToRad(), PList::First(), Variant::GetComplexData(), Variant::GetFloat(), PComplexData::GetList(), PComplexData::IsList(), Variant::IsNumber(), pDouble, PI, Recurse(), and PError::SignalFatalError().

Referenced by DegToRad().

◆ Div()

Variant PEBLMath::Div ( Variant  v)

Definition at line 756 of file PEBLMath.cpp.

757{
758 PError::SignalFatalError("Function [Div] Not implemented.");
759 return Variant(0);
760}

References PError::SignalFatalError().

◆ Exp()

Variant PEBLMath::Exp ( Variant  v)

Definition at line 294 of file PEBLMath.cpp.

295{
296
297 PList * plist = v.GetComplexData()->GetList();
298 Variant v1 = plist->First();
299 if(v1.IsNumber())
300 {
301 //return Variant((pDouble)expl(v1.GetFloat()));
302 return Variant((pDouble)exp(v1.GetFloat()));
303 }
304 else if(v1.GetComplexData()->IsList())
305 {
306 return Recurse(v1, Exp);
307
308 }
309 else
310 {
311
312 PError::SignalFatalError("Non-numeric argument in Exp");
313 return 0;
314 }
315
316}

References Exp(), PList::First(), Variant::GetComplexData(), Variant::GetFloat(), PComplexData::GetList(), PComplexData::IsList(), Variant::IsNumber(), pDouble, Recurse(), and PError::SignalFatalError().

Referenced by Exp(), and main().

◆ Floor()

Variant PEBLMath::Floor ( Variant  v)

Definition at line 662 of file PEBLMath.cpp.

663{
664
665
666 PList * plist = v.GetComplexData()->GetList();
667 Variant v1 = plist->First();
668 if(v1.IsNumber())
669 {
670 //return Variant((pInt)(floorl(v1.GetFloat())));
671 return Variant((pInt)(floor(v1.GetFloat())));
672 }
673 else if(v1.GetComplexData()->IsList())
674 {
675 return Recurse(v1, Floor);
676
677 }
678 else
679 {
680 PError::SignalFatalError("Non-numeric argument in [Floor]");
681 return 0;
682 }
683}

References PList::First(), Floor(), Variant::GetComplexData(), Variant::GetFloat(), PComplexData::GetList(), PComplexData::IsList(), Variant::IsNumber(), pInt, Recurse(), and PError::SignalFatalError().

Referenced by Floor().

◆ Ln()

Variant PEBLMath::Ln ( Variant  v)

Definition at line 231 of file PEBLMath.cpp.

232{
233
234 PList * plist = v.GetComplexData()->GetList();
235
236 Variant v1 = plist->First();
237 if(v1.IsNumber())
238 {
239 //return Variant((pDouble)logl(v1.GetFloat()));
240 return Variant((pDouble)log(v1.GetFloat()));
241 }
242 else if(v1.GetComplexData()->IsList())
243 {
244 return Recurse(v1, Ln);
245
246 }
247 else
248 {
249
250 PError::SignalFatalError("Non-numeric argument in Ln");
251 return 0;
252 }
253
254}

References PList::First(), Variant::GetComplexData(), Variant::GetFloat(), PComplexData::GetList(), PComplexData::IsList(), Variant::IsNumber(), Ln(), pDouble, Recurse(), and PError::SignalFatalError().

Referenced by Ln(), and main().

◆ Log10()

Variant PEBLMath::Log10 ( Variant  v)

Definition at line 179 of file PEBLMath.cpp.

180{
181
182// std::cout << "log10a\n";
183// std::cout << "(" << v << ")" << std::endl;
184 PList * plist = v.GetComplexData()->GetList();
185 Variant v1 = plist->First();
186// std::cout << "v1: " << v1 << std::endl;
187 if(v1.IsNumber())
188 {
189 //return Variant((pDouble)log10l(v1.GetFloat()));
190 return Variant((pDouble)log10(v1.GetFloat()));
191
192 }
193#ifndef PEBL_EMSCRIPTEN
194 else if(v1.GetComplexData()->IsList())
195 {
196 return Recurse(v1, Log10);
197
198 }
199#endif
200 else
201 {
202 PError::SignalFatalError("Non-numeric argument in Log10");
203 }
204
205 return 0;
206}

References PList::First(), Variant::GetComplexData(), Variant::GetFloat(), PComplexData::GetList(), PComplexData::IsList(), Variant::IsNumber(), Log10(), pDouble, Recurse(), and PError::SignalFatalError().

Referenced by Log10(), and main().

◆ Log2()

Variant PEBLMath::Log2 ( Variant  v)

Definition at line 208 of file PEBLMath.cpp.

209{
210
211 //std::cout <<"Log2: " << v << std::endl;
212 PList * plist = v.GetComplexData()->GetList();
213 Variant v1 = plist->First();
214 if(v1.IsNumber())
215 {
216 return Variant(PEBLUtility::Log2(v1.GetFloat()));
217 }
218 else if(v1.GetComplexData()->IsList())
219 {
220 return Recurse(v1, Log2);
221
222 }
223 else
224 {
225 PError::SignalFatalError("Non-numeric argument in Log2");
226 return 0;
227 }
228
229}
PEBLUtility::Log2
pDouble Log2(pDouble val)
Definition PEBLUtility.cpp:578

References PList::First(), Variant::GetComplexData(), Variant::GetFloat(), PComplexData::GetList(), PComplexData::IsList(), Variant::IsNumber(), PEBLUtility::Log2(), Log2(), Recurse(), and PError::SignalFatalError().

Referenced by Log2(), and main().

◆ LogN()

Variant PEBLMath::LogN ( Variant  v)

Definition at line 257 of file PEBLMath.cpp.

258{
259 //This has two arguments; the number and the base.
260
261 PList * plist = v.GetComplexData()->GetList();
262 Variant number = plist->First(); //plist->PopFront();
263
264 //Don't get the second argument right away--if the first argument is
265 //a list, we should just pass it along to the recurse2 function.
266
267 Variant base = plist->Nth(2);// plist->PopFront(); //Get the base argument
268
269if(number.IsNumber())
270 {
271 //return Variant((pDouble)(logl(number.GetFloat())/ logl(base.GetFloat())));
272 return Variant((pDouble)(log(number.GetFloat())/ log(base.GetFloat())));
273 }
274 else if(number.GetComplexData()->IsList())
275 {
276
277 //counted_ptr<PEBLObjectBase>tmp2 = counted_ptr<PEBLObjectBase>(plist);
278 //PComplexData * pcd = new PComplexData(tmp2);
279
280 //Variant args = Variant(pcd);
281 //delete pcd;
282 //pcd=NULL;
283 Variant retval = Recurse2(number, LogN, base);
284 return retval;
285 }
286 else
287 {
288 PError::SignalFatalError("Non-numeric argument in LogN");
289 return 0;
290 }
291}
PList::Nth
Variant Nth(unsigned int n)
Definition PList.cpp:181

References PList::First(), Variant::GetComplexData(), Variant::GetFloat(), PComplexData::GetList(), PComplexData::IsList(), Variant::IsNumber(), LogN(), PList::Nth(), pDouble, Recurse2(), and PError::SignalFatalError().

Referenced by LogN().

◆ Mod()

Variant PEBLMath::Mod ( Variant  v)

Definition at line 733 of file PEBLMath.cpp.

734{
735
736 PList * plist = v.GetComplexData()->GetList();
737
738
739 PError::AssertType( plist->First(), PEAT_NUMBER, "Argument error in first parameter of Mod(<number>,<number>)");
740 pInt v1 = plist->First(); //plist->PopFront();
741
742
743 PError::AssertType( plist->Nth(2), PEAT_NUMBER, "Argument error in second parameter of Mod(<number>,<number>)");
744 pInt v2 = plist->Nth(2); //plist->PopFront();
745
746
747 double remainder =((pDouble)v1/v2 - (v1/v2));
748 if( remainder < 0 ) remainder += 1.0;
749 if(remainder >= 1.0) remainder = 0;
750
751 return Variant((pInt)(remainder * v2 + .00001));
752}
PEAT_NUMBER
@ PEAT_NUMBER
Definition PError.h:43
PError::AssertType
void AssertType(Variant v, int type, const std::string &outsidemessage)

References PError::AssertType(), PList::First(), Variant::GetComplexData(), PComplexData::GetList(), PList::Nth(), pDouble, PEAT_NUMBER, and pInt.

◆ NthRoot()

Variant PEBLMath::NthRoot ( Variant  v)

Definition at line 379 of file PEBLMath.cpp.

380{
381 //This has two arguments; the number and the root.
382
383 PList * plist = v.GetComplexData()->GetList();
384 Variant number = plist->First(); //plist->PopFront();
385
386 //Don't get the second argument right away--if the first argument is
387 //a list, we should just pass it along to the recurse2 function.
388
389 if(number.IsNumber())
390 {
391 Variant root = plist->Nth(2);// plist->PopFront(); //Get the base argument
392 //return (pDouble)powl((pDouble)number,(pDouble)( 1 / root.GetFloat()));
393 return (pDouble)pow((pDouble)number,(pDouble)( 1 / root.GetFloat()));
394 }
395 else if(number.GetComplexData()->IsList())
396 {
397 counted_ptr<PEBLObjectBase> tmp = v.GetComplexData()->GetObject();
398 PComplexData * pcd = new PComplexData(tmp);
399 Variant args = Variant(pcd);
400 delete pcd;
401 pcd=NULL;
402
403 Variant retval = Recurse2(number, NthRoot, args);
404 return retval;
405
406
407 }
408 else
409 {
410
411 PError::SignalFatalError("Non-numeric argument in NthRoot");
412 return 0;
413 }
414}
NULL
#define NULL
Definition BinReloc.cpp:317
PComplexData::GetObject
counted_ptr< PEBLObjectBase > GetObject() const
Definition PComplexData.cpp:99
counted_ptr
Definition rc_ptrs.h:66

References PList::First(), Variant::GetComplexData(), Variant::GetFloat(), PComplexData::GetList(), PComplexData::GetObject(), PComplexData::IsList(), Variant::IsNumber(), PList::Nth(), NthRoot(), NULL, pDouble, Recurse2(), and PError::SignalFatalError().

Referenced by NthRoot().

◆ Pow()

Variant PEBLMath::Pow ( Variant  v)

Definition at line 319 of file PEBLMath.cpp.

320{
321 //This has two arguments; the number and the base.
322
323 PList * plist = v.GetComplexData()->GetList();
324 Variant base = plist->First();// plist->PopFront();
325
326 //Don't get the second argument right away--if the first argument is
327 //a list, we should just pass it along to the recurse2 function.
328
329 if(base.IsNumber())
330 {
331 Variant power = plist->Nth(2); //plist->PopFront(); //Get the base argument
332 //return (pDouble)powl((pDouble)base, (pDouble)power);
333 return (pDouble)pow((pDouble)base, (pDouble)power);
334 }
335 else if(base.GetComplexData()->IsList())
336 {
337
338 counted_ptr<PEBLObjectBase> tmp = v.GetComplexData()->GetObject();
339 PComplexData * pcd = new PComplexData(tmp);
340 Variant args = Variant(pcd);
341 delete pcd;
342 pcd=NULL;
343
344 Variant retval = Recurse2(base, Pow, args);
345
346 return retval;
347 }
348 else
349 {
350 PError::SignalFatalError("Non-numeric argument in Pow");
351 return 0;
352 }
353}

References PList::First(), Variant::GetComplexData(), PComplexData::GetList(), PComplexData::GetObject(), PComplexData::IsList(), Variant::IsNumber(), PList::Nth(), NULL, pDouble, Pow(), Recurse2(), and PError::SignalFatalError().

Referenced by Pow().

◆ RadToDeg()

Variant PEBLMath::RadToDeg ( Variant  v)

Definition at line 600 of file PEBLMath.cpp.

601{
602
603 PList * plist = v.GetComplexData()->GetList();
604
605
606 Variant v1 = plist->First(); //plist->PopFront();
607
608 if(v1.IsNumber())
609 {
610 return Variant(v1.GetFloat() * 180/ PI);
611 }
612 else if(v1.GetComplexData()->IsList())
613 {
614 return Recurse(v1, RadToDeg);
615
616 }
617 else
618 {
619 PError::SignalFatalError("Non-numeric argument in [RadToDeg]");
620 return 0;
621 }
622}

References PList::First(), Variant::GetComplexData(), Variant::GetFloat(), PComplexData::GetList(), PComplexData::IsList(), Variant::IsNumber(), PI, RadToDeg(), Recurse(), and PError::SignalFatalError().

Referenced by RadToDeg().

◆ Random()

Variant PEBLMath::Random ( Variant  v)

This function takes no parameters, and returns a floating-point Variant between 0 and 1.

Definition at line 995 of file PEBLMath.cpp.

996{
997 //v[1] should have nothing in it.
998
999 return Variant(PEBLUtility::RandomUniform());
1000}
PEBLUtility::RandomUniform
pDouble RandomUniform()
Definition PEBLUtility.cpp:560

References PEBLUtility::RandomUniform().

◆ RandomBernoulli()

Variant PEBLMath::RandomBernoulli ( Variant  v)

This takes a value p and returns either 1 with probability p and 0 with probability 1-p.

Definition at line 1160 of file PEBLMath.cpp.

1161{
1162
1163 PList * plist = v.GetComplexData()->GetList();
1164
1165 //v[1] should have the parameter
1166
1167 PError::AssertType(plist->First(), PEAT_NUMBER, "Argument error in first parameter function [RandomBinomial(<p>, <N>)]: ");
1168 pDouble p = plist->First();// plist->PopFront();
1169
1170 if(PEBLUtility::RandomUniform() < p)
1171 return Variant(1);
1172 else
1173 return Variant(0);
1174}

References PError::AssertType(), PList::First(), Variant::GetComplexData(), PComplexData::GetList(), pDouble, PEAT_NUMBER, and PEBLUtility::RandomUniform().

◆ RandomBinomial()

Variant PEBLMath::RandomBinomial ( Variant  v)

This takes a value p and a value N. It will generate N random numbers and report the count of the numbers that are below p.

Definition at line 1135 of file PEBLMath.cpp.

1136{
1137
1138 PList * plist = v.GetComplexData()->GetList();
1139
1140 //v[1] should have the parameter
1141
1142 PError::AssertType(plist->First(), PEAT_NUMBER, "Argument error in first parameter function [RandomBinomial(<p>, <N>)]: ");
1143 pDouble p = plist->First();// plist->PopFront();
1144 PError::AssertType(plist->Nth(2), PEAT_NUMBER, "Argument error in second parameter function [RandomBinomial(<p>, <N>)]: ");
1145 pInt N = plist->Nth(2); //plist->PopFront();
1146
1147 pInt count = 0;
1148 for(int i = 0; i < N; i++)
1149 {
1150 if(PEBLUtility::RandomUniform() < p) count++;
1151 }
1152
1153
1154 return Variant(count);
1155}
count
int count
Definition test.cpp:12

References PError::AssertType(), count, PList::First(), Variant::GetComplexData(), PComplexData::GetList(), PList::Nth(), pDouble, PEAT_NUMBER, pInt, and PEBLUtility::RandomUniform().

◆ RandomDiscrete()

Variant PEBLMath::RandomDiscrete ( Variant  v)

This function takes one parameter, which should be a positive integer. It will return an integer between 1 and argument (inclusive), each with equal probability. If the argument is a float, it will get truncated down; if it is less than 1, 1 will be returned, but a warning message will be triggered.

Definition at line 1008 of file PEBLMath.cpp.

1009{
1010 //v[1] should have the parameter
1011
1012 PList * plist = v.GetComplexData()->GetList();
1013
1014
1015 PError::AssertType(plist->First(), PEAT_NUMBER, "Argument error in function [RandomDiscrete(<number>)]: ");
1016
1017 int v1 = plist->First();
1018 if(v1 < 1)
1019 {
1020 string message = "Function [RandomDiscrete] requires argument >= 1; received ";
1021 message += v1;
1022 message += ". Returning 1.";
1023 PError::SignalWarning(message);
1024 return Variant(1);
1025 }
1026
1027 //Since the most-significant digits are a bit predictable, use the remainder function
1028 unsigned int r = rand();
1029 return Variant((pInt)(r % v1)+ 1 );
1030
1031}
PError::SignalWarning
void SignalWarning(const std::string &message)
Definition PError.cpp:119

References PError::AssertType(), PList::First(), Variant::GetComplexData(), PComplexData::GetList(), PEAT_NUMBER, pInt, and PError::SignalWarning().

◆ RandomExponential()

Variant PEBLMath::RandomExponential ( Variant  v)

This function takes a single parameter; the mean of of an exponential random variable. It will return a floating-point value which is a sample from this distribution.

Definition at line 1086 of file PEBLMath.cpp.

1087{
1088 //v[1] should be lambda, the mean of the Exponential RV.
1089
1090 PList * plist = v.GetComplexData()->GetList();
1091
1092
1093 PError::AssertType(plist->First(), PEAT_NUMBER, "Argument error in function [RandomExponential(<number>)]: ");
1094 pDouble lambda = plist->First(); //plist->PopFront();
1095
1096 //The value of lambda may not be able to vary freely--It may not be able to be negative.
1097 //This should be checked for.
1098
1099 return Variant(-lambda * log(PEBLUtility::RandomUniform()));
1100}

References PError::AssertType(), PList::First(), Variant::GetComplexData(), PComplexData::GetList(), pDouble, PEAT_NUMBER, and PEBLUtility::RandomUniform().

◆ RandomizeTimer()

Variant PEBLMath::RandomizeTimer ( Variant  v)

This will explicitly re-seed the RNG with the time of day. Useful for multi-session experiments where you want to use the same random seed across days to randomize, but want differences in order between days, etc.

Definition at line 967 of file PEBLMath.cpp.

968{
969 time_t now = time(0);
970 srand((unsigned int)now);
971 long unsigned int tmp = (long unsigned int)now;
972 return Variant(tmp);
973
974}

◆ RandomLogistic()

Variant PEBLMath::RandomLogistic ( Variant  v)

This function takes no parameters; It will return a floating-point value which is a sample from the vanilla logistic distribution f(x) = exp(x)/(1+exp(x))

Definition at line 1105 of file PEBLMath.cpp.

1106{
1107 //v should have no parameters
1108
1109 double p = PEBLUtility::RandomUniform();
1110
1111 return Variant(log(p/(1-p)));
1112}

References PEBLUtility::RandomUniform().

◆ RandomLogNormal()

Variant PEBLMath::RandomLogNormal ( Variant  v)

This function takes two parameters, the spread and median of a log-normal random variable.

Definition at line 1117 of file PEBLMath.cpp.

1118{
1119
1120
1121 PList * plist = v.GetComplexData()->GetList();
1122
1123 //v[1] should be median, v[2] should be the spread
1124 PError::AssertType(plist->First(), PEAT_NUMBER, "Argument error in first parameter function [RandomLogNormal(<median>, <spread>)]: ");
1125 pDouble median = plist->First(); //plist->PopFront();
1126
1127 PError::AssertType(plist->Nth(2), PEAT_NUMBER, "Argument error in second parameter function [RandomLogNormal(<median>, <spread>)]: ");
1128 pDouble spread = plist->Nth(2);// plist->PopFront();
1129
1130 return Variant(median * exp(spread * PEBLUtility::RandomNormal()));
1131}
PEBLUtility::RandomNormal
pDouble RandomNormal()
Definition PEBLUtility.cpp:569

References PError::AssertType(), PList::First(), Variant::GetComplexData(), PComplexData::GetList(), PList::Nth(), pDouble, PEAT_NUMBER, and PEBLUtility::RandomNormal().

◆ RandomNormal()

Variant PEBLMath::RandomNormal ( Variant  v)

This function takes two parameters (mean and stdev), It will return a floating- point number which is a sample from the N(0,1) distribution. Values are calculated using the Box-Mueller technique.

Definition at line 1065 of file PEBLMath.cpp.

1066{
1067
1068 PList * plist = v.GetComplexData()->GetList();
1069
1070 //v[1] should be mean, v[2] should be standard deviation.
1071
1072 PError::AssertType(plist->First(), PEAT_NUMBER, "Argument error in first parameter of function [RandomNormal(<mean>, <stdev>)]: ");
1073 pDouble mean = plist->First(); //plist->PopFront();
1074
1075 PError::AssertType(plist->Nth(2), PEAT_NUMBER, "Argument error in second parameter function [RandomNormal(<mean>, <stdev>)]: ");
1076 pDouble stdev = plist->Nth(2);// plist->PopFront();
1077
1078 if(stdev < 0) PError::SignalFatalError("Standard Deviation parameter of function [RandomNormal(<mean>,<stdev>)] must be positive.");
1079
1080 return Variant(mean + PEBLUtility::RandomNormal()*stdev);
1081}

References PError::AssertType(), PList::First(), Variant::GetComplexData(), PComplexData::GetList(), PList::Nth(), pDouble, PEAT_NUMBER, PEBLUtility::RandomNormal(), and PError::SignalFatalError().

◆ RandomUniform()

Variant PEBLMath::RandomUniform ( Variant  v)

This function takes one parameter, which should be a positive number. It will return a floating-point variant between 0 and the argument.

Definition at line 1037 of file PEBLMath.cpp.

1038{
1039
1040
1041 PList * plist = v.GetComplexData()->GetList();
1042
1043 //v[1] should have the parameter
1044
1045 PError::AssertType(plist->First(), PEAT_NUMBER, "Argument error in function [RandomUniform(<number>)]: ");
1046
1047 pDouble upperbound = plist->First(); //plist->PopFront();
1048 if(upperbound < 0)
1049 {
1050 std::ostringstream message;
1051 message << "Function [RandomUniform] requires argument >= 0; received "
1052 << upperbound;
1053 PError::SignalFatalError(message.str().c_str());
1054 }
1055
1056 return Variant(upperbound * PEBLUtility::RandomUniform());
1057}

References PError::AssertType(), PList::First(), Variant::GetComplexData(), PComplexData::GetList(), pDouble, PEAT_NUMBER, PEBLUtility::RandomUniform(), and PError::SignalFatalError().

◆ Recurse()

Variant PEBLMath::Recurse ( Variant  v,
Variant(*)(Variant)  funcname 
)

Definition at line 55 of file PEBLMath.cpp.

56{
57
58 //If this function is called, v is a list of elements.
59 //We should call the function on each element of the list, creating
60 //a list of the results, turn this into a variant, and return it.
61
62 //Get the list of variants.
63
64 PList * plist = v.GetComplexData()->GetList();
65 //Make a results list
66 PList * resultslist = new PList();
67 //Declare a temporary argument list.
68 //Now, apply
69
70
71 PList* arglist;
72 counted_ptr<PEBLObjectBase> tmpObj;
73 Variant tmpVariant;
74 PComplexData * tmpPCD;
75
76
77 std::vector<Variant>::iterator p = plist->Begin();
78 while(p != plist->End())
79 {
80
81 //Create new variant list to pass to function
82 arglist = new PList();
83
84 //Add the first element of plist to it
85 arglist->PushBack(*p);
86
87 //make it into a PCD
88 tmpObj = counted_ptr<PEBLObjectBase>(arglist);
89 tmpPCD = (new PComplexData(tmpObj));
90 //Create variant to hold it.
91 tmpVariant = Variant(tmpPCD);
92
93 //tmpPCD is now part of tmpVariant, so we don't need to destroy it.
94 //delete tmpPCD;
95 tmpPCD=NULL;
96
97
98 Variant result = funcname(tmpVariant);
99 resultslist->PushBack(result);
100
101 //Get rid of arglist so we can make a new one.
102 delete arglist;
103 arglist = NULL;
104 //plist->PopFront(); We need to do something here to handle recursion with vectors instead of lists
105 //e.g., an iterator.
106 //PError::SignalFatalError("Recursive operation not supported.");
107 p++;
108 }
109
110 //Now, resultslist is a PList. Put it into a PCD.
111 counted_ptr<PEBLObjectBase> tmp = counted_ptr<PEBLObjectBase>(resultslist);
112 PComplexData * pcd = new PComplexData(tmp);
113
114 Variant tmp2 = Variant(pcd);
115 delete pcd;
116 pcd=NULL;
117 return tmp2;
118
119}
PList::End
std::vector< Variant >::const_iterator End() const
Definition PList.cpp:132
PList::Begin
std::vector< Variant >::const_iterator Begin() const
Definition PList.cpp:127
PList::PushBack
void PushBack(const Variant &v)
Definition PList.cpp:149

References PList::Begin(), PList::End(), Variant::GetComplexData(), PComplexData::GetList(), NULL, and PList::PushBack().

Referenced by Abs(), AbsFloor(), ACos(), ASin(), ATan(), Ceiling(), Cos(), DegToRad(), Exp(), Floor(), Ln(), Log10(), Log2(), RadToDeg(), Round(), Sign(), Sin(), Sqrt(), and Tan().

◆ Recurse2()

Variant PEBLMath::Recurse2 ( Variant  v,
Variant(*)(Variant)  funcname,
Variant  argument 
)

Definition at line 124 of file PEBLMath.cpp.

125{
126
127 //If this function is called, v is a list of elements.
128 //We should call the function on each element of the list, creating
129 //a list of the results, turn this into a variant, and return it.
130
131 //Get the list of variants.
132
133 PList * plist = v.GetComplexData()->GetList();
134 //Make a results list
135
136 PList * resultslist = new PList();
137
138
139 std::vector<Variant>::iterator p = plist->Begin();
140
141 //Add the argument onto arglist. argument should be a list of variants.
142 //Declare an temporary argument list.
143 //counted_ptr<PEBLObjectBase> tmp2 = argument.GetComplexData()->GetObject();
144 //Variant arg2 = ((PList*)(tmp2.get()));
145
146 PList * arglist = NULL;
147
148 PComplexData * pcd;
149 while(p != plist->End())
150 {
151 arglist = new PList();
152 arglist->PushBack(*p); //Add the critical argument
153 arglist->PushBack(argument); //add second argument
154 counted_ptr<PEBLObjectBase> tmp3 = counted_ptr<PEBLObjectBase>(arglist);
155
156 pcd = new PComplexData(tmp3);
157 Variant tmp = Variant(pcd);
158 resultslist->PushBack(funcname(tmp)); //Execute
159
160 delete arglist;
161 arglist = NULL;
162
163
164 p++;
165 }
166
167 //Now, resultslist is a PList. Put it into a PCD.
168 pcd = new PComplexData(counted_ptr<PEBLObjectBase>(resultslist));
169 Variant tmp3 = Variant(pcd);
170 delete pcd;
171 pcd=NULL;
172
173 return tmp3;
174}

References PList::Begin(), PList::End(), Variant::GetComplexData(), PComplexData::GetList(), NULL, and PList::PushBack().

Referenced by LogN(), NthRoot(), and Pow().

◆ Round()

Variant PEBLMath::Round ( Variant  v)

Definition at line 626 of file PEBLMath.cpp.

627{
628
629
630 PList * plist = v.GetComplexData()->GetList();
631
632 Variant v1 = plist->First();
633 if(v1.IsNumber())
634 {
635
636 //plist->PopFront();
637
638 if(plist->Length()==1)
639 {
640 return Variant(PEBLUtility::Round(v1.GetFloat()));
641 }else{
642
643 Variant v2 =plist->Nth(2);
644
645 PError::AssertType(v2, PEAT_INTEGER,"Second (optional) argument in [Round(number, precision)] must be an integer: ");
646 return Variant(PEBLUtility::Round(v1.GetFloat(),v2.GetInteger()));
647 }
648
649 }
650 else if(v1.GetComplexData()->IsList())
651 {
652 return Recurse(v1, Round);
653 }
654 else
655 {
656 PError::SignalFatalError("Non-numeric argument in [Round]");
657 return 0;
658 }
659}
PEAT_INTEGER
@ PEAT_INTEGER
Definition PError.h:44
PList::Length
unsigned long Length() const
Definition PList.h:89
Variant::GetInteger
pInt GetInteger() const
Definition Variant.cpp:997
PEBLMath::Recurse
Variant Recurse(Variant v, Variant(*)(Variant))
Definition PEBLMath.cpp:55
PEBLUtility::Round
pInt Round(pDouble val)
Definition PEBLUtility.cpp:589

References PError::AssertType(), PList::First(), Variant::GetComplexData(), Variant::GetFloat(), Variant::GetInteger(), PComplexData::GetList(), PComplexData::IsList(), Variant::IsNumber(), PList::Length(), PList::Nth(), PEAT_INTEGER, Recurse(), PEBLUtility::Round(), Round(), and PError::SignalFatalError().

Referenced by Round().

◆ SeedRNG()

Variant PEBLMath::SeedRNG ( Variant  v)

This explicitly seeds the Random Number Generator. By Default, The PEBL Environment will call this on a time-of-day function on start-up.

Definition at line 977 of file PEBLMath.cpp.

978{
979 //v[1] should have the parameter
980
981 PList * plist = v.GetComplexData()->GetList();
982
983 PError::AssertType(plist->First().GetInteger(), PEAT_NUMBER, "Argument error in function [SeedRNG(<number>)]: ");
984
985 pInt seed = plist->First();
986 srand((unsigned int)seed);
987
988 return Variant(true);
989}

References PError::AssertType(), PList::First(), Variant::GetComplexData(), Variant::GetInteger(), PComplexData::GetList(), PEAT_NUMBER, and pInt.

◆ Sign()

Variant PEBLMath::Sign ( Variant  v)

Definition at line 825 of file PEBLMath.cpp.

826{
827
828
829 PList * plist = v.GetComplexData()->GetList();
830
831 Variant v1 = plist->First();
832 if(v1.IsNumber())
833 {
834 return (v1.GetFloat()<0)? -1: 1;
835 }
836 else if(v1.GetComplexData()->IsList())
837 {
838 return Recurse(v1, Sign);
839
840 }
841 else
842 {
843 PError::SignalFatalError("Non-numeric argument in Function [Sign]");
844 return 0;
845 }
846
847}

References PList::First(), Variant::GetComplexData(), Variant::GetFloat(), PComplexData::GetList(), PComplexData::IsList(), Variant::IsNumber(), Recurse(), Sign(), and PError::SignalFatalError().

Referenced by Sign().

◆ Sin()

Variant PEBLMath::Sin ( Variant  v)

Sin takes one parameter.

Definition at line 448 of file PEBLMath.cpp.

449{
450
451 PList * plist = v.GetComplexData()->GetList();
452
453 Variant v1 = plist->First();
454 if(v1.IsNumber())
455 {
456 //return Variant((pDouble)sinl(v1.GetFloat()));
457 return Variant((pDouble)sin(v1.GetFloat()));
458 }
459 else if(v1.GetComplexData()->IsList())
460 {
461 return Recurse(v1, Sin);
462
463 }
464 else
465 {
466 PError::SignalFatalError("Non-numeric argument in [Sin]");
467
468 return 0;
469 }
470}

References PList::First(), Variant::GetComplexData(), Variant::GetFloat(), PComplexData::GetList(), PComplexData::IsList(), Variant::IsNumber(), pDouble, Recurse(), PError::SignalFatalError(), and Sin().

Referenced by main(), and Sin().

◆ Sqrt()

Variant PEBLMath::Sqrt ( Variant  v)

Definition at line 355 of file PEBLMath.cpp.

356{
357
358 PList * plist = v.GetComplexData()->GetList();
359 Variant v1 = plist->First();
360 if(v1.IsNumber())
361 {
362 //return Variant((pDouble)sqrtl(v1.GetFloat()));
363 return Variant((pDouble)sqrt(v1.GetFloat()));
364 }
365 else if(v1.GetComplexData()->IsList())
366 {
367 return Recurse(v1, Sqrt);
368
369 }
370 else
371 {
372 PError::SignalFatalError("Non-numeric argument in Sqrt");
373 return 0;
374 }
375
376}

References PList::First(), Variant::GetComplexData(), Variant::GetFloat(), PComplexData::GetList(), PComplexData::IsList(), Variant::IsNumber(), pDouble, Recurse(), PError::SignalFatalError(), and Sqrt().

Referenced by main(), and Sqrt().

◆ Tan()

Variant PEBLMath::Tan ( Variant  v)

Definition at line 421 of file PEBLMath.cpp.

422{
423
424 PList * plist = v.GetComplexData()->GetList();
425 Variant v1 = plist->First();
426 if(v1.IsNumber())
427 {
428 //return Variant((pDouble)tanl(v1.GetFloat()));
429 return Variant((pDouble)tan(v1.GetFloat()));
430 }
431 else if(v1.GetComplexData()->IsList())
432 {
433 return Recurse(v1, Tan);
434
435 }
436 else
437 {
438 PError::SignalFatalError("Non-numeric argument in Tan");
439
440 return 0;
441 }
442
443}

References PList::First(), Variant::GetComplexData(), Variant::GetFloat(), PComplexData::GetList(), PComplexData::IsList(), Variant::IsNumber(), pDouble, Recurse(), PError::SignalFatalError(), and Tan().

Referenced by main(), and Tan().

◆ ToFloat()

Variant PEBLMath::ToFloat ( Variant  v)

Definition at line 772 of file PEBLMath.cpp.

773{
774 PList * plist = v.GetComplexData()->GetList();
775 return Variant(plist->First().GetFloat());
776
777}

References PList::First(), Variant::GetComplexData(), Variant::GetFloat(), and PComplexData::GetList().

◆ ToInt()

Variant PEBLMath::ToInt ( Variant  v)

Definition at line 764 of file PEBLMath.cpp.

765{
766
767
768 PList * plist = v.GetComplexData()->GetList();
769 return Variant(plist->First().GetInteger());
770}

References PList::First(), Variant::GetComplexData(), Variant::GetInteger(), and PComplexData::GetList().

◆ ToNumber()

Variant PEBLMath::ToNumber ( Variant  v)

Definition at line 786 of file PEBLMath.cpp.

787{
788
789 PList * plist = v.GetComplexData()->GetList();
790
791 Variant v1 = plist->First();
792
793 //If v is a string, then turn it either into an integer or a float,
794 //depending on whether there is a '.' in it.
795
796 if(v1.IsString())
797 {
798 bool hasPoint = false;
799
800 std::string tmp = v.GetString();
801 std::string::iterator i = tmp.begin();
802
803 while(i != tmp.end() && hasPoint == false)
804 {
805 if(*i == '.')
806 hasPoint = true;
807 i++;
808 }
809
810 if(hasPoint)
811 {
812 return Variant(v1.GetFloat());
813 }
814 else
815 {
816 return Variant(v1.GetInteger());
817 }
818
819 }
820
821 return Variant(v1.GetFloat());
822}
Variant::IsString
bool IsString() const
Definition Variant.cpp:948
Variant::GetString
std::string GetString() const
Definition Variant.cpp:1056

References PList::First(), Variant::GetComplexData(), Variant::GetFloat(), Variant::GetInteger(), PComplexData::GetList(), Variant::GetString(), and Variant::IsString().

◆ ToString()

Variant PEBLMath::ToString ( Variant  v)

Definition at line 779 of file PEBLMath.cpp.

780{
781 PList * plist = v.GetComplexData()->GetList();
782 return Variant(plist->First().GetString());
783}

References PList::First(), Variant::GetComplexData(), PComplexData::GetList(), and Variant::GetString().

Variable Documentation

◆ FunctionTable

PEBL_Function_Type PEBLMath::FunctionTable[]

Definition at line 51 of file Functions.h.

52 {
53 {(char*)"LOG10", Log10, 1, 1},
54 {(char*)"LOG2", Log2, 1, 1},
55 {(char*)"LN", Ln, 1, 1},
56 {(char*)"LOGN", LogN, 2, 2},
57 {(char*)"EXP", Exp, 1, 1},
58 {(char*)"POW", Pow, 2, 2},
59 {(char*)"SQRT", Sqrt, 1, 1},
60 {(char*)"NTHROOT", NthRoot, 2, 2},
61
62 //Trigonometry
63 {(char*)"TAN", Tan, 1, 1},
64 {(char*)"SIN", Sin, 1, 1},
65 {(char*)"COS", Cos, 1, 1},
66 {(char*)"ATAN", ATan, 1, 1},
67 {(char*)"ASIN", ASin, 1, 1},
68 {(char*)"ACOS", ACos, 1, 1},
69 {(char*)"DEGTORAD", DegToRad, 1, 1},
70 {(char*)"RADTODEG", RadToDeg, 1, 1},
71
72 //Rounding
73 {(char*)"ROUND", Round, 1, 2},
74 {(char*)"FLOOR", Floor, 1, 1},
75 {(char*)"CEILING", Ceiling, 1, 1},
76
77 {(char*)"ABSFLOOR", AbsFloor, 1, 1},
78
79 //Modular Arithmetic
80 {(char*)"MOD", Mod, 2, 2},
81 {(char*)"DIV", Div, 2, 2},
82
83 //Coercion
84 {(char*)"TOINTEGER", ToInt, 1, 1},
85 {(char*)"TOFLOAT", ToFloat, 1, 1},
86 {(char*)"TONUMBER", ToNumber, 1, 1},
87 {(char*)"TOSTRING", ToString, 1, 1},
88
89
90 //Other
91 {(char*)"SIGN", Sign, 1, 1},
92 {(char*)"ABS", Abs, 1, 1},
93
94 //Statistical (operates on a list; ignores non-numeric elements.)
95// {(char*)"MEAN", Mean, 1, 1},
96// {(char*)"MIN", Min, 1, 9999},
97// {(char*)"MAX", Max, 1, 9999},
98// {(char*)"STDEV", StDev, 1, 1},
99// {(char*)"MEDIAN", Median, 1, 1},
100// {(char*)"QUANTILE", Quantile, 2, 2},
101
102 {(char*)"RANDOMIZETIMER", RandomizeTimer, 0, 0},
103 {(char*)"SEEDRNG", SeedRNG, 1, 1},
104 {(char*)"RANDOM", Random, 0, 0},
105 {(char*)"RANDOMDISCRETE", RandomDiscrete, 1, 1},
106 {(char*)"RANDOMUNIFORM", RandomUniform, 1, 1},
107 {(char*)"RANDOMNORMAL", RandomNormal, 2, 2},
108 {(char*)"RANDOMEXPONENTIAL", RandomExponential, 1, 1},
109 {(char*)"RANDOMLOGISTIC", RandomLogistic, 1, 1},
110 {(char*)"RANDOMLOGNORMAL", RandomLogNormal, 2, 2},
111 {(char*)"RANDOMBINOMIAL", RandomBinomial, 2, 2},
112 {(char*)"RANDOMBERNOULLI", RandomBernoulli, 1, 1},
113
114 {0, 0, 0, 0}
115 };

Referenced by Loader::LoadLibraryFunctions().