rendered paste body// =====================================================================================================================================
// allen_cpu_lib_math.c - Allen version 2.0
// =====================================================================================================================================
//
// This file is part of the Allen Library.
// Last modified: Saturday July 14, 2007.
//
// Copyright (c) 2007, Archville, BSD License.
// A copy can be found here: http://www.opensource.org/licenses/bsd-license.php
// Initally based on Salvatore <antirez> Sanfilippo within Picol 0.1.0
//
// All rights reserved.
//
// Redistribution and use in source and binary forms, with or without modification,
// are permitted provided that the following conditions are met:
//
// * Redistributions of source code must retain the above copyright notice,
// this list of conditions and the following disclaimer.
// * Redistributions in binary form must reproduce the above copyright notice,
// this list of conditions and the following disclaimer in the documentation
// and/or other materials provided with the distribution.
// * Neither the name of the Garabatos de licor nor the names of its contributors may
// be used to endorse or promote products derived from this software
// without specific prior written permission.
//
// This software is provided by the copyright holders and contributors
// "as is" and any express or implied warranties, including, but not
// limited to, the implied warranties of merchantability and fitness for
// a particular purpose are disclaimed. in no event shall the copyright owner or
// contributors be liable for any direct, indirect, incidental, special,
// exemplary, or consequential damages (including, but not limited to,
// procurement of substitute goods or services; loss of use, data, or
// profits; or business interruption) however caused and on any theory of
// liability, whether in contract, strict liability, or tort (including
// negligence or otherwise) arising in any way out of the use of this
// software, even if advised of the possibility of such damage.
// =====================================================================================================================================
// Include libraries.
// =====================================================================================================================================
#include <stdio.h> // Standard input/output.
#include <stdlib.h> // Standard C libraries.
#include <string.h> // String libraries.
#include <math.h> // Math libraries.
#include <ctype.h> // Types and conversion libraries.
#include "allen_interpreter.h" // Main interpreter library.
#include "allen_parser.h" // Main parser library.
// =====================================================================================================================================
// Parameters.
// =====================================================================================================================================
#define TLIB_MATH_BSIZE 1024 // Buffer size.
// =====================================================================================================================================
// Possible errors.
// =====================================================================================================================================
#define TLIB_MATH_EHLP "math.?: command not found in library" // Error: Command not found in math library.
// =====================================================================================================================================
// Tokens.
// ====================================================================================================================================
#define TLIB_MATH_ABS "math.abs" // Absolute value.
#define TLIB_MATH_ACC "math.acos" // Arc cosine.
#define TLIB_MATH_ACS "math.asin" // Arc sine.
#define TLIB_MATH_ACT "math.atan" // Arc tangent.
#define TLIB_MATH_AHC "math.acosh" // Hyperbolic arc cosine.
#define TLIB_MATH_AHS "math.asinh" // Hyperbolic arc sine.
#define TLIB_MATH_AHT "math.atanh" // Hyperbolic arc tangent.
#define TLIB_MATH_BAS "math.base" // Base conversion.
#define TLIB_MATH_CBR "math.cbrt" // Cube root.
#define TLIB_MATH_CIL "math.ceil" // Round value up.
#define TLIB_MATH_COS "math.cos" // Cosine.
#define TLIB_MATH_CSH "math.cosh" // Hyperbolic cosine.
#define TLIB_MATH_DEC "math.dec" // Decrement value.
#define TLIB_MATH_EXP "math.exp" // Exponent.
#define TLIB_MATH_FLR "math.floor" // Round value down.
#define TLIB_MATH_INC "math.inc" // Increment value.
#define TLIB_MATH_LOG "math.log" // Logarithm.
#define TLIB_MATH_RAM "math.rand" // Random number.
#define TLIB_MATH_RND "math.round" // Round to next integer.
#define TLIB_MATH_SIN "math.sin" // Sine.
#define TLIB_MATH_SSH "math.sinh" // Hyperbolic sine.
#define TLIB_MATH_SGN "math.sign" // Sign change.
#define TLIB_MATH_SQR "math.sqrt" // Square root.
#define TLIB_MATH_TAN "math.tan" // Tangent.
#define TLIB_MATH_TSH "math.tanh" // Hyperbolic tangent.
// =====================================================================================================================================
// Helper Function.
// =====================================================================================================================================
#define TLIB_MATH_HLP "math.?" // Helper function.
// =====================================================================================================================================
// Basic math operators.
// =====================================================================================================================================
// Allows to perform regular mathematic operations on value lists
// and return results based on their expresions.
// Index: Example: Result:
// AllenVM_CPU_LIB_MATH_ABS(); :: math.abs -10 10.000000
// AllenVM_CPU_LIB_MATH_ACC(); :: math.acos 0.2 1.369438
// AllenVM_CPU_LIB_MATH_ACS(); :: math.asin 0.2 0.201358
// AllenVM_CPU_LIB_MATH_ACT(); :: math.atan 0.2 0.197396
// AllenVM_CPU_LIB_MATH_AHC(); :: math.acosh 20 3.688254
// AllenVM_CPU_LIB_MATH_AHS(); :: math.asinh 20 3.689504
// AllenVM_CPU_LIB_MATH_AHT(); :: math.atanh 0.9 1.472219
// AllenVM_CPU_LIB_MATH_BAS(); :: math.base 10 2 1010
// AllenVM_CPU_LIB_MATH_CBR(); :: math.cbrt 27 3.000000
// AllenVM_CPU_LIB_MATH_CIL(); :: math.ceil 23.4 24.000000
// AllenVM_CPU_LIB_MATH_COS(); :: math.cos 0 1.000000
// AllenVM_CPU_LIB_MATH_CSH(); :: math.cosh 1 1.543081
// AllenVM_CPU_LIB_MATH_DEC(); :: math.dec 2 3 -1.000000
// AllenVM_CPU_LIB_MATH_EXP(); :: math.exp 2 7.389056
// AllenVM_CPU_LIB_MATH_FLR(); :: math.floor 21.9 21.000000
// AllenVM_CPU_LIB_MATH_INC(); :: math.inc 2.3 5.000000
// AllenVM_CPU_LIB_MATH_LOG(); :: math.log 10 2.302585
// AllenVM_CPU_LIB_MATH_RAM(); :: math.rand 100 78.000000
// AllenVM_CPU_LIB_MATH_RND(); :: math.round 99.2 99.000000
// AllenVM_CPU_LIB_MATH_SIN(); :: math.sin -1 -0.841471
// AllenVM_CPU_LIB_MATH_SSH(); :: math.sinh -1 -1.175201
// AllenVM_CPU_LIB_MATH_SGN(); :: math.sign +2 -2.000000
// AllenVM_CPU_LIB_MATH_SQR(); :: math.sqrt 16 4.000000
// AllenVM_CPU_LIB_MATH_TAN(); :: math.tan 5 -3.380515
// AllenVM_CPU_LIB_MATH_TSH(); :: math.tanh 5 0.999909
// Total: 25.
// -------------------------------------------------------------------------------------------------------------------------------------
// Function: AllenVM_CPU_LIB_MATH_ABS();
// Purpose: Absolute value.
// Returns: Expression result.
// -------------------------------------------------------------------------------------------------------------------------------------
static int AllenVM_CPU_LIB_MATH_ABS(struct AllenInterp *i, int argc, char **argv, void *pd) {
if(argc != 2) return AllenVM_CPU_Error(i,argv[0]); // Check parameters.
float c=abs(atof(argv[1])); // Calculate.
char buf[TLIB_MATH_BSIZE]; // Create buffer.
snprintf(buf,TLIB_MATH_BSIZE,"%f",c); // Copy result to buffer as float.
AllenVM_InterpSetResult(i,buf); // Set interpreter result.
return Allen_VM_OK; // Everything ok.
}
// -------------------------------------------------------------------------------------------------------------------------------------
// Function: AllenVM_CPU_LIB_MATH_ACC();
// Purpose: Arc cosine.
// Returns: Expression result.
// -------------------------------------------------------------------------------------------------------------------------------------
static int AllenVM_CPU_LIB_MATH_ACC(struct AllenInterp *i, int argc, char **argv, void *pd) {
if(argc != 2) return AllenVM_CPU_Error(i,argv[0]); // Check parameters.
float c=acos(atof(argv[1])); // Calculate.
char buf[TLIB_MATH_BSIZE]; // Create buffer.
snprintf(buf,TLIB_MATH_BSIZE,"%f",c); // Copy result to buffer as float.
AllenVM_InterpSetResult(i,buf); // Set interpreter result.
return Allen_VM_OK; // Everything ok.
}
// -------------------------------------------------------------------------------------------------------------------------------------
// Function: AllenVM_CPU_LIB_MATH_ACS();
// Purpose: Arc sine.
// Returns: Expression result.
// -------------------------------------------------------------------------------------------------------------------------------------
static int AllenVM_CPU_LIB_MATH_ACS(struct AllenInterp *i, int argc, char **argv, void *pd) {
if(argc != 2) return AllenVM_CPU_Error(i,argv[0]); // Check parameters.
float c=asin(atof(argv[1])); // Calculate.
char buf[TLIB_MATH_BSIZE]; // Create buffer.
snprintf(buf,TLIB_MATH_BSIZE,"%f",c); // Copy result to buffer as float.
AllenVM_InterpSetResult(i,buf); // Set interpreter result.
return Allen_VM_OK; // Everything ok.
}
// -------------------------------------------------------------------------------------------------------------------------------------
// Function: AllenVM_CPU_LIB_MATH_ACT();
// Purpose: Arc tangent.
// Returns: Expression result.
// -------------------------------------------------------------------------------------------------------------------------------------
static int AllenVM_CPU_LIB_MATH_ACT(struct AllenInterp *i, int argc, char **argv, void *pd) {
if(argc != 2) return AllenVM_CPU_Error(i,argv[0]); // Check parameters.
float c=atan(atof(argv[1])); // Calculate.
char buf[TLIB_MATH_BSIZE]; // Create buffer.
snprintf(buf,TLIB_MATH_BSIZE,"%f",c); // Copy result to buffer as float.
AllenVM_InterpSetResult(i,buf); // Set interpreter result.
return Allen_VM_OK; // Everything ok.
}
// -------------------------------------------------------------------------------------------------------------------------------------
// Function: AllenVM_CPU_LIB_MATH_AHC();
// Purpose: Hyperbolic arc cosine.
// Returns: Expression result.
// -------------------------------------------------------------------------------------------------------------------------------------
static int AllenVM_CPU_LIB_MATH_AHC(struct AllenInterp *i, int argc, char **argv, void *pd) {
if(argc != 2) return AllenVM_CPU_Error(i,argv[0]); // Check parameters.
float c=acosh(atof(argv[1])); // Calculate.
char buf[TLIB_MATH_BSIZE]; // Create buffer.
snprintf(buf,TLIB_MATH_BSIZE,"%f",c); // Copy result to buffer as float.
AllenVM_InterpSetResult(i,buf); // Set interpreter result.
return Allen_VM_OK; // Everything ok.
}
// -------------------------------------------------------------------------------------------------------------------------------------
// Function: AllenVM_CPU_LIB_MATH_AHS();
// Purpose: Hyperbolic arc sine.
// Returns: Expression result.
// -------------------------------------------------------------------------------------------------------------------------------------
static int AllenVM_CPU_LIB_MATH_AHS(struct AllenInterp *i, int argc, char **argv, void *pd) {
if(argc != 2) return AllenVM_CPU_Error(i,argv[0]); // Check parameters.
float c=asinh(atof(argv[1])); // Calculate.
char buf[TLIB_MATH_BSIZE]; // Create buffer.
snprintf(buf,TLIB_MATH_BSIZE,"%f",c); // Copy result to buffer as float.
AllenVM_InterpSetResult(i,buf); // Set interpreter result.
return Allen_VM_OK; // Everything ok.
}
// -------------------------------------------------------------------------------------------------------------------------------------
// Function: AllenVM_CPU_LIB_MATH_AHT();
// Purpose: Hyperbolic arc tangent.
// Returns: Expression result.
// -------------------------------------------------------------------------------------------------------------------------------------
static int AllenVM_CPU_LIB_MATH_AHT(struct AllenInterp *i, int argc, char **argv, void *pd) {
if(argc != 2) return AllenVM_CPU_Error(i,argv[0]); // Check parameters.
float c=atanh(atof(argv[1])); // Calculate.
char buf[TLIB_MATH_BSIZE]; // Create buffer.
snprintf(buf,TLIB_MATH_BSIZE,"%f",c); // Copy result to buffer as float.
AllenVM_InterpSetResult(i,buf); // Set interpreter result.
return Allen_VM_OK; // Everything ok.
}
// -------------------------------------------------------------------------------------------------------------------------------------
// Function: AllenVM_CPU_LIB_MATH_BAS();
// Purpose: Base conversion.
// Returns: Expression result.
// -------------------------------------------------------------------------------------------------------------------------------------
static int AllenVM_CPU_LIB_MATH_BAS(struct AllenInterp *i, int argc, char **argv, void *pd) {
if (argc != 3) return AllenVM_CPU_Error(i,argv[0]); // Check parameters.
if (abs(atoi(argv[2]))<2) return AllenVM_CPU_Error(i,argv[0]); // Base should be at least two.
char base_digits[16] = {'0', '1', '2', '3', '4', '5', '6', '7', // Possible base values:
'8', '9', 'A', 'B', 'C', 'D', 'E', 'F'}; // From 0 to F, has in hex.
int index = 0, result[TLIB_MATH_BSIZE]; // Index and result.
int number = abs(atoi(argv[1])), base = abs(atoi(argv[2])); // Number and base to convert.
while(number != 0) {result[index] = number % base; number = number / base; ++index;} // While not zero: Apply modulus and divide.
char buf[TLIB_MATH_BSIZE]; // Create buffer.
buf[index]='\0'; int c = 0; // Add \0 to the string.
for(--index; index>=0; index--,c++) // Through index values:
buf[c] = base_digits[result[index]]; // Copy current character.
AllenVM_InterpSetResult(i,buf); // Set interpreter result.
return Allen_VM_OK; // Everything ok.
}
// -------------------------------------------------------------------------------------------------------------------------------------
// Function: AllenVM_CPU_LIB_MATH_CBR();
// Purpose: Cube root.
// Returns: Expression result.
// -------------------------------------------------------------------------------------------------------------------------------------
static int AllenVM_CPU_LIB_MATH_CBR(struct AllenInterp *i, int argc, char **argv, void *pd) {
if(argc != 2) return AllenVM_CPU_Error(i,argv[0]); // Check parameters.
float c=cbrt(atof(argv[1])); // Calculate.
char buf[TLIB_MATH_BSIZE]; // Create buffer.
snprintf(buf,TLIB_MATH_BSIZE,"%f",c); // Copy result to buffer as float.
AllenVM_InterpSetResult(i,buf); // Set interpreter result.
return Allen_VM_OK; // Everything ok.
}
// -------------------------------------------------------------------------------------------------------------------------------------
// Function: AllenVM_CPU_LIB_MATH_CIL();
// Purpose: Round value up.
// Returns: Expression result.
// -------------------------------------------------------------------------------------------------------------------------------------
static int AllenVM_CPU_LIB_MATH_CIL(struct AllenInterp *i, int argc, char **argv, void *pd) {
if(argc != 2) return AllenVM_CPU_Error(i,argv[0]); // Check parameters.
float c=ceil(atof(argv[1])); // Calculate.
char buf[TLIB_MATH_BSIZE]; // Create buffer.
snprintf(buf,TLIB_MATH_BSIZE,"%f",c); // Copy result to buffer as float.
AllenVM_InterpSetResult(i,buf); // Set interpreter result.
return Allen_VM_OK; // Everything ok.
}
// -------------------------------------------------------------------------------------------------------------------------------------
// Function: AllenVM_CPU_LIB_MATH_COS();
// Purpose: Cosine.
// Returns: Expression result.
// -------------------------------------------------------------------------------------------------------------------------------------
static int AllenVM_CPU_LIB_MATH_COS(struct AllenInterp *i, int argc, char **argv, void *pd) {
if(argc != 2) return AllenVM_CPU_Error(i,argv[0]); // Check parameters.
float c=cos(atof(argv[1])); // Calculate.
char buf[TLIB_MATH_BSIZE]; // Create buffer.
snprintf(buf,TLIB_MATH_BSIZE,"%f",c); // Copy result to buffer as float.
AllenVM_InterpSetResult(i,buf); // Set interpreter result.
return Allen_VM_OK; // Everything ok.
}
// -------------------------------------------------------------------------------------------------------------------------------------
// Function: AllenVM_CPU_LIB_MATH_CSH();
// Purpose: Hyperbolic cosine.
// Returns: Expression result.
// -------------------------------------------------------------------------------------------------------------------------------------
static int AllenVM_CPU_LIB_MATH_CSH(struct AllenInterp *i, int argc, char **argv, void *pd) {
if(argc != 2) return AllenVM_CPU_Error(i,argv[0]); // Check parameters.
float c=cosh(atof(argv[1])); // Calculate.
char buf[TLIB_MATH_BSIZE]; // Create buffer.
snprintf(buf,TLIB_MATH_BSIZE,"%f",c); // Copy result to buffer as float.
AllenVM_InterpSetResult(i,buf); // Set interpreter result.
return Allen_VM_OK; // Everything ok.
}
// -------------------------------------------------------------------------------------------------------------------------------------
// Function: AllenVM_CPU_LIB_MATH_DEC();
// Purpose: Decrement value.
// Returns: Expression result.
// -------------------------------------------------------------------------------------------------------------------------------------
static int AllenVM_CPU_LIB_MATH_DEC(struct AllenInterp *i, int argc, char **argv, void *pd) {
if(argc != 3) return AllenVM_CPU_Error(i,argv[0]); // Check parameters.
float c= atof(argv[1]) - atof(argv[2]); // Calculate.
char buf[TLIB_MATH_BSIZE]; // Create buffer.
snprintf(buf,TLIB_MATH_BSIZE,"%f",c); // Copy result to buffer as float.
AllenVM_InterpSetResult(i,buf); // Set interpreter result.
return Allen_VM_OK; // Everything ok.
}
// -------------------------------------------------------------------------------------------------------------------------------------
// Function: AllenVM_CPU_LIB_MATH_EXP();
// Purpose: Exponent.
// Returns: Expression result.
// -------------------------------------------------------------------------------------------------------------------------------------
static int AllenVM_CPU_LIB_MATH_EXP(struct AllenInterp *i, int argc, char **argv, void *pd) {
if(argc != 2) return AllenVM_CPU_Error(i,argv[0]); // Check parameters.
float c=exp(atof(argv[1])); // Calculate.
char buf[TLIB_MATH_BSIZE]; // Create buffer.
snprintf(buf,TLIB_MATH_BSIZE,"%f",c); // Copy result to buffer as float.
AllenVM_InterpSetResult(i,buf); // Set interpreter result.
return Allen_VM_OK; // Everything ok.
}
// -------------------------------------------------------------------------------------------------------------------------------------
// Function: AllenVM_CPU_LIB_MATH_FLR();
// Purpose: Round value down.
// Returns: Expression result.
// -------------------------------------------------------------------------------------------------------------------------------------
static int AllenVM_CPU_LIB_MATH_FLR(struct AllenInterp *i, int argc, char **argv, void *pd) {
if(argc != 2) return AllenVM_CPU_Error(i,argv[0]); // Check parameters.
float c=floor(atof(argv[1])); // Calculate.
char buf[TLIB_MATH_BSIZE]; // Create buffer.
snprintf(buf,TLIB_MATH_BSIZE,"%f",c); // Copy result to buffer as float.
AllenVM_InterpSetResult(i,buf); // Set interpreter result.
return Allen_VM_OK; // Everything ok.
}
// -------------------------------------------------------------------------------------------------------------------------------------
// Function: AllenVM_CPU_LIB_MATH_INC();
// Purpose: Increment.
// Returns: Expression result.
// -------------------------------------------------------------------------------------------------------------------------------------
static int AllenVM_CPU_LIB_MATH_INC(struct AllenInterp *i, int argc, char **argv, void *pd) {
if(argc != 3) return AllenVM_CPU_Error(i,argv[0]); // Check parameters.
float c= atof(argv[1]) + atof(argv[2]); // Calculate.
char buf[TLIB_MATH_BSIZE]; // Create buffer.
snprintf(buf,TLIB_MATH_BSIZE,"%f",c); // Copy result to buffer as float.
AllenVM_InterpSetResult(i,buf); // Set interpreter result.
return Allen_VM_OK; // Everything ok.
}
// -------------------------------------------------------------------------------------------------------------------------------------
// Function: AllenVM_CPU_LIB_MATH_LOG();
// Purpose: Logarithm.
// Returns: Expression result.
// -------------------------------------------------------------------------------------------------------------------------------------
static int AllenVM_CPU_LIB_MATH_LOG(struct AllenInterp *i, int argc, char **argv, void *pd) {
if(argc != 2) return AllenVM_CPU_Error(i,argv[0]); // Check parameters.
float c=log(atof(argv[1])); // Calculate.
char buf[TLIB_MATH_BSIZE]; // Create buffer.
snprintf(buf,TLIB_MATH_BSIZE,"%f",c); // Copy result to buffer as float.
AllenVM_InterpSetResult(i,buf); // Set interpreter result.
return Allen_VM_OK; // Everything ok.
}
// -------------------------------------------------------------------------------------------------------------------------------------
// Function: AllenVM_CPU_LIB_MATH_RAM();
// Purpose: Random number.
// Returns: Random number up to argument.
// -------------------------------------------------------------------------------------------------------------------------------------
static int AllenVM_CPU_LIB_MATH_RAM(struct AllenInterp *i, int argc, char **argv, void *pd) {
if(argc != 2) return AllenVM_CPU_Error(i,argv[0]); // Check first parameter.
if(atoi(argv[1]) == 0) return AllenVM_CPU_Error(i,argv[0]); // Check zero value.
float c=rand() % atoi(argv[1]); // Calculate.
char buf[TLIB_MATH_BSIZE]; // Create buffer.
snprintf(buf,TLIB_MATH_BSIZE,"%f",c); // Copy result to buffer as float.
AllenVM_InterpSetResult(i,buf); // Set interpreter result.
return Allen_VM_OK; // Everything ok.
}
// -------------------------------------------------------------------------------------------------------------------------------------
// Function: AllenVM_CPU_LIB_MATH_RND();
// Purpose: Round to next integer.
// Returns: Expression result.
// -------------------------------------------------------------------------------------------------------------------------------------
static int AllenVM_CPU_LIB_MATH_RND(struct AllenInterp *i, int argc, char **argv, void *pd) {
if(argc != 2) return AllenVM_CPU_Error(i,argv[0]); // Check parameters.
float c = atof(argv[1]); float d = c - (int) c; // Calculate.
char buf[TLIB_MATH_BSIZE]; // Create buffer.
snprintf(buf,TLIB_MATH_BSIZE,"%f", d < 0.5 ? floor(c) : ceil(c)); // Copy result to buffer as float.
AllenVM_InterpSetResult(i,buf); // Set interpreter result.
return Allen_VM_OK; // Everything ok.
}
// -------------------------------------------------------------------------------------------------------------------------------------
// Function: AllenVM_CPU_LIB_MATH_SIG();
// Purpose: Sign change.
// Returns: Expression result.
// -------------------------------------------------------------------------------------------------------------------------------------
static int AllenVM_CPU_LIB_MATH_SGN(struct AllenInterp *i, int argc, char **argv, void *pd) {
if(argc != 2) return AllenVM_CPU_Error(i,argv[0]); // Check parameters.
float c=atof(argv[1]) * -1; // Calculate.
char buf[TLIB_MATH_BSIZE]; // Create buffer.
snprintf(buf,TLIB_MATH_BSIZE,"%f",c); // Copy result to buffer as float.
AllenVM_InterpSetResult(i,buf); // Set interpreter result.
return Allen_VM_OK; // Everything ok.
}
// -------------------------------------------------------------------------------------------------------------------------------------
// Function: AllenVM_CPU_LIB_MATH_SIN();
// Purpose: Sine.
// Returns: Expression result.
// -------------------------------------------------------------------------------------------------------------------------------------
static int AllenVM_CPU_LIB_MATH_SIN(struct AllenInterp *i, int argc, char **argv, void *pd) {
if(argc != 2) return AllenVM_CPU_Error(i,argv[0]); // Check parameters.
float c=sin(atof(argv[1])); // Calculate.
char buf[TLIB_MATH_BSIZE]; // Create buffer.
snprintf(buf,TLIB_MATH_BSIZE,"%f",c); // Copy result to buffer as float.
AllenVM_InterpSetResult(i,buf); // Set interpreter result.
return Allen_VM_OK; // Everything ok.
}
// -------------------------------------------------------------------------------------------------------------------------------------
// Function: AllenVM_CPU_LIB_MATH_SSH();
// Purpose: Hyperbolic sine.
// Returns: Expression result.
// -------------------------------------------------------------------------------------------------------------------------------------
static int AllenVM_CPU_LIB_MATH_SSH(struct AllenInterp *i, int argc, char **argv, void *pd) {
if(argc != 2) return AllenVM_CPU_Error(i,argv[0]); // Check parameters.
float c=sinh(atof(argv[1])); // Calculate.
char buf[TLIB_MATH_BSIZE]; // Create buffer.
snprintf(buf,TLIB_MATH_BSIZE,"%f",c); // Copy result to buffer as float.
AllenVM_InterpSetResult(i,buf); // Set interpreter result.
return Allen_VM_OK; // Everything ok.
}
// -------------------------------------------------------------------------------------------------------------------------------------
// Function: AllenVM_CPU_LIB_MATH_SQR();
// Purpose: Square root.
// Returns: Expression result.
// -------------------------------------------------------------------------------------------------------------------------------------
static int AllenVM_CPU_LIB_MATH_SQR(struct AllenInterp *i, int argc, char **argv, void *pd) {
if(argc != 2) return AllenVM_CPU_Error(i,argv[0]); // Check parameters.
float c=sqrt(atof(argv[1])); // Calculate.
char buf[TLIB_MATH_BSIZE]; // Create buffer.
snprintf(buf,TLIB_MATH_BSIZE,"%f",c); // Copy result to buffer as float.
AllenVM_InterpSetResult(i,buf); // Set interpreter result.
return Allen_VM_OK; // Everything ok.
}
// -------------------------------------------------------------------------------------------------------------------------------------
// Function: AllenVM_CPU_LIB_MATH_TAN();
// Purpose: Tangent.
// Returns: Expression result.
// -------------------------------------------------------------------------------------------------------------------------------------
static int AllenVM_CPU_LIB_MATH_TAN(struct AllenInterp *i, int argc, char **argv, void *pd) {
if(argc != 2) return AllenVM_CPU_Error(i,argv[0]); // Check parameters.
float c=tan(atof(argv[1])); // Calculate.
char buf[TLIB_MATH_BSIZE]; // Create buffer.
snprintf(buf,TLIB_MATH_BSIZE,"%f",c); // Copy result to buffer as float.
AllenVM_InterpSetResult(i,buf); // Set interpreter result.
return Allen_VM_OK; // Everything ok.
}
// -------------------------------------------------------------------------------------------------------------------------------------
// Function: AllenVM_CPU_LIB_MATH_TSH();
// Purpose: Hyperbolic tangent.
// Returns: Expression result.
// -------------------------------------------------------------------------------------------------------------------------------------
static int AllenVM_CPU_LIB_MATH_TSH(struct AllenInterp *i, int argc, char **argv, void *pd) {
if(argc != 2) return AllenVM_CPU_Error(i,argv[0]); // Check parameters.
float c=tanh(atof(argv[1])); // Calculate.
char buf[TLIB_MATH_BSIZE]; // Create buffer.
snprintf(buf,TLIB_MATH_BSIZE,"%f",c); // Copy result to buffer as float.
AllenVM_InterpSetResult(i,buf); // Set interpreter result.
return Allen_VM_OK; // Everything ok.
}
// -------------------------------------------------------------------------------------------------------------------------------------
// Function: AllenVM_CPU_LIB_MATH_HLP();
// Purpose: Adds help facilities
// Returns: Expression result.
// -------------------------------------------------------------------------------------------------------------------------------------
static int AllenVM_CPU_LIB_MATH_HLP(struct AllenInterp *i, int argc, char **argv, void *pd) {
if(argc != 2) return AllenVM_CPU_Error(i,argv[0]); // Check parameters.
if(!strcmp(TLIB_MATH_ABS,argv[1])) { // Compare parameters.
puts("Description: Returns an absolute value."); // Description.
puts("Returns: Float positive number from expression result."); // Returns.
puts("Sample: math.abs -2 => 2.000000"); // Sample function.
puts("Parameters: min: 1 max: 1"); // Parameters needed.
AllenVM_InterpSetResult(i,TLIB_MATH_ABS); // Set interpreter result.
return Allen_VM_OK; } // Everything ok.
if(!strcmp(TLIB_MATH_ACC,argv[1])) { // Compare parameters.
puts("Description: Arc cosine."); // Description.
puts("Returns: Float number from expression result."); // Returns.
puts("Sample: math.acos 0.2 => 1.369438"); // Sample function.
puts("Parameters: min: 1 max: 1"); // Parameters needed.
AllenVM_InterpSetResult(i,TLIB_MATH_ACC); // Set interpreter result.
return Allen_VM_OK; } // Everything ok.
if(!strcmp(TLIB_MATH_ACS,argv[1])) { // Compare parameters.
puts("Description: Arc sine."); // Description.
puts("Returns: Float number from expression result."); // Returns.
puts("Sample: math.asin 0.2 => 0.201358"); // Sample function.
puts("Parameters: min: 1 max: 1"); // Parameters needed.
AllenVM_InterpSetResult(i,TLIB_MATH_ACS); // Set interpreter result.
return Allen_VM_OK; } // Everything ok.
if(!strcmp(TLIB_MATH_ACT,argv[1])) { // Compare parameters.
puts("Description: Arc tangent."); // Description.
puts("Returns: Float number from expression result."); // Returns.
puts("Sample: math.atan 0.2 => 0.197396"); // Sample function.
puts("Parameters: min: 1 max: 1"); // Parameters needed.
AllenVM_InterpSetResult(i,TLIB_MATH_ACT); // Set interpreter result.
return Allen_VM_OK; } // Everything ok.
if(!strcmp(TLIB_MATH_AHC,argv[1])) { // Compare parameters.
puts("Description: Hyperbolic arc cosine."); // Description.
puts("Returns: Float number from expression result."); // Returns.
puts("Sample: math.acosh 20 => 3.688254"); // Sample function.
puts("Parameters: min: 1 max: 1"); // Parameters needed.
AllenVM_InterpSetResult(i,TLIB_MATH_AHC); // Set interpreter result.
return Allen_VM_OK; } // Everything ok.
if(!strcmp(TLIB_MATH_AHS,argv[1])) { // Compare parameters.
puts("Description: Hyperbolic arc sine."); // Description.
puts("Returns: Float number from expression result."); // Returns.
puts("Sample: math.asinh 20 => 3.689504"); // Sample function.
puts("Parameters: min: 1 max: 1"); // Parameters needed.
AllenVM_InterpSetResult(i,TLIB_MATH_AHS); // Set interpreter result.
return Allen_VM_OK; } // Everything ok.
if(!strcmp(TLIB_MATH_AHT,argv[1])) { // Compare parameters.
puts("Description: Hyperbolic arc tangent."); // Description.
puts("Returns: Float number from expression result."); // Returns.
puts("Sample: math.atanh 0.9 => 1.472219"); // Sample function.
puts("Parameters: min: 1 max: 1"); // Parameters needed.
AllenVM_InterpSetResult(i,TLIB_MATH_AHT); // Set interpreter result.
return Allen_VM_OK; } // Everything ok.
if(!strcmp(TLIB_MATH_BAS,argv[1])) { // Compare parameters.
puts("Description: Base conversion."); // Description.
puts("Returns: Integer number from expression result."); // Returns.
puts("Sample: math.base 10 2 => 1010"); // Sample function.
puts("Parameters: min: 1 max: 1"); // Parameters needed.
AllenVM_InterpSetResult(i,TLIB_MATH_BAS); // Set interpreter result.
return Allen_VM_OK; } // Everything ok.
if(!strcmp(TLIB_MATH_CBR,argv[1])) { // Compare parameters.
puts("Description: Returns the cube root of it's argument."); // Description.
puts("Returns: Float number from expression result."); // Returns.
puts("Sample: math.cbrt 27 => 3.000000"); // Sample function.
puts("Parameters: min: 1 max: 1"); // Parameters needed.
AllenVM_InterpSetResult(i,TLIB_MATH_CBR); // Set interpreter result.
return Allen_VM_OK; } // Everything ok.
if(!strcmp(TLIB_MATH_CIL,argv[1])) { // Compare parameters.
puts("Description: Round a value up to the next integer."); // Description.
puts("Returns: Float number from expression result."); // Returns.
puts("Sample: math.ceil 2.124 => 3.000000"); // Sample function.
puts("Parameters: min: 1 max: 1"); // Parameters needed.
AllenVM_InterpSetResult(i,TLIB_MATH_CIL); // Set interpreter result.
return Allen_VM_OK; } // Everything ok.
if(!strcmp(TLIB_MATH_COS,argv[1])) { // Compare parameters.
puts("Description: Returns the cosine of a given angle."); // Description.
puts("Returns: Float number from expression result."); // Returns.
puts("Sample: math.cos 0 => 1.000000"); // Sample function.
puts("Parameters: min: 1 max: 1"); // Parameters needed.
AllenVM_InterpSetResult(i,TLIB_MATH_COS); // Set interpreter result.
return Allen_VM_OK; } // Everything ok.
if(!strcmp(TLIB_MATH_CSH,argv[1])) { // Compare parameters.
puts("Description: Returns the hyperbolic cosine of a given angle."); // Description.
puts("Returns: Float number from expression result."); // Returns.
puts("Sample: math.cosh 1 => 1.543081"); // Sample function.
puts("Parameters: min: 1 max: 1"); // Parameters needed.
AllenVM_InterpSetResult(i,TLIB_MATH_CSH); // Set interpreter result.
return Allen_VM_OK; } // Everything ok.
if(!strcmp(TLIB_MATH_DEC,argv[1])) { // Compare parameters.
puts("Description: Decrements a value in N units."); // Description.
puts("Returns: Float number from expression result."); // Returns.
puts("Sample: math.dec 100 20 => 80.000000"); // Sample function.
puts("Parameters: min: 2 max: 2"); // Parameters needed.
AllenVM_InterpSetResult(i,TLIB_MATH_DEC); // Set interpreter result.
return Allen_VM_OK; } // Everything ok.
if(!strcmp(TLIB_MATH_EXP,argv[1])) { // Compare parameters.
puts("Description: Returns the exponential function of arg."); // Description.
puts("Returns: Float number from expression result."); // Returns.
puts("Sample: math.exp 2 => 7.389056"); // Sample function.
puts("Parameters: min: 1 max: 1"); // Parameters needed.
AllenVM_InterpSetResult(i,TLIB_MATH_EXP); // Set interpreter result.
return Allen_VM_OK; } // Everything ok.
if(!strcmp(TLIB_MATH_FLR,argv[1])) { // Compare parameters.
puts("Description: Round a value down to the next integer."); // Description.
puts("Returns: Float number from expression result."); // Returns.
puts("Sample: math.floor 4.524 => 4.000000"); // Sample function.
puts("Parameters: min: 1 max: 1"); // Parameters needed.
AllenVM_InterpSetResult(i,TLIB_MATH_FLR); // Set interpreter result.
return Allen_VM_OK; } // Everything ok.
if(!strcmp(TLIB_MATH_INC,argv[1])) { // Compare parameters.
puts("Description: Increments a value in N units."); // Description.
puts("Returns: Float number from expression result."); // Returns.
puts("Sample: math.inc 100 20 => 120.000000"); // Sample function.
puts("Parameters: min: 2 max: 2"); // Parameters needed.
AllenVM_InterpSetResult(i,TLIB_MATH_INC); // Set interpreter result.
return Allen_VM_OK; } // Everything ok.
if(!strcmp(TLIB_MATH_LOG,argv[1])) { // Compare parameters.
puts("Description: Returns the natural logarithm of arg."); // Description.
puts("Returns: Float number from expression result."); // Returns.
puts("Sample: math.log 10 => 2.302585"); // Sample function.
puts("Parameters: min: 1 max: 1"); // Parameters needed.
AllenVM_InterpSetResult(i,TLIB_MATH_LOG); // Set interpreter result.
return Allen_VM_OK; } // Everything ok.
if(!strcmp(TLIB_MATH_RAM,argv[1])) { // Compare parameters.
puts("Description: Returns a random number from 0 to arg."); // Description.
puts("Returns: Float number from expression result."); // Returns.
puts("Sample: math.rand 100 => 78.000000"); // Sample function.
puts("Parameters: min: 1 max: 1"); // Parameters needed.
AllenVM_InterpSetResult(i,TLIB_MATH_RAM); // Set interpreter result.
return Allen_VM_OK; } // Everything ok.
if(!strcmp(TLIB_MATH_RND,argv[1])) { // Compare parameters.
puts("Description: Rounds value to the next integer."); // Description.
puts("Returns: Float number from expression result."); // Returns.
puts("Sample: math.rand 99.21 => 99.000000"); // Sample function.
puts("Parameters: min: 1 max: 1"); // Parameters needed.
AllenVM_InterpSetResult(i,TLIB_MATH_RND); // Set interpreter result.
return Allen_VM_OK; } // Everything ok.
if(!strcmp(TLIB_MATH_SIN,argv[1])) { // Compare parameters.
puts("Description: Returns the sine of a given angle."); // Description.
puts("Returns: Float number from expression result."); // Returns.
puts("Sample: math.sin -1 => -0.841471"); // Sample function.
puts("Parameters: min: 1 max: 1"); // Parameters needed.
AllenVM_InterpSetResult(i,TLIB_MATH_SIN); // Set interpreter result.
return Allen_VM_OK; } // Everything ok.
if(!strcmp(TLIB_MATH_SSH,argv[1])) { // Compare parameters.
puts("Description: Returns the hyperbolic sine of a given angle."); // Description.
puts("Returns: Float number from expression result."); // Returns.
puts("Sample: math.sinh -1 => -1.175201"); // Sample function.
puts("Parameters: min: 1 max: 1"); // Parameters needed.
AllenVM_InterpSetResult(i,TLIB_MATH_SSH); // Set interpreter result.
return Allen_VM_OK; } // Everything ok.
if(!strcmp(TLIB_MATH_SGN,argv[1])) { // Compare parameters.
puts("Description: Changes sign on it's argument."); // Description.
puts("Returns: Float number from expression result."); // Returns.
puts("Sample: math.sign +2 => -2.000000"); // Sample function.
puts("Parameters: min: 1 max: 1"); // Parameters needed.
AllenVM_InterpSetResult(i,TLIB_MATH_SGN); // Set interpreter result.
return Allen_VM_OK; } // Everything ok.
if(!strcmp(TLIB_MATH_SQR,argv[1])) { // Compare parameters.
puts("Description: Returns the square root of arg."); // Description.
puts("Returns: Float number from expression result."); // Returns.
puts("Sample: math.sqrt 16 => 4.000000"); // Sample function.
puts("Parameters: min: 1 max: 1"); // Parameters needed.
AllenVM_InterpSetResult(i,TLIB_MATH_SQR); // Set interpreter result.
return Allen_VM_OK; } // Everything ok.
if(!strcmp(TLIB_MATH_TAN,argv[1])) { // Compare parameters.
puts("Description: Returns the tangent of a given angle."); // Description.
puts("Returns: Float number from expression result."); // Returns.
puts("Sample: math.tan 5 => -3.380515"); // Sample function.
puts("Parameters: min: 1 max: 1"); // Parameters needed.
AllenVM_InterpSetResult(i,TLIB_MATH_TAN); // Set interpreter result.
return Allen_VM_OK; } // Everything ok.
if(!strcmp(TLIB_MATH_TSH,argv[1])) { // Compare parameters.
puts("Description: Returns the hyperbolic tangent of a given angle."); // Description.
puts("Returns: Float number from expression result."); // Returns.
puts("Sample: math.tanh 5 => 0.999909"); // Sample function.
puts("Parameters: min: 1 max: 1"); // Parameters needed.
AllenVM_InterpSetResult(i,TLIB_MATH_TSH); // Set interpreter result.
return Allen_VM_OK; } // Everything ok.
AllenVM_InterpSetResult(i,""); // Set interpreter result.
return AllenVM_CPU_Error(i,TLIB_MATH_EHLP); // Command not found.
}
// -------------------------------------------------------------------------------------------------------------------------------------
// Function: AllenVM_CPU_LIB_MATH_ADD();
// Purpose: Add instructions to the CPU.
// Returns: Void (nothing).
// -------------------------------------------------------------------------------------------------------------------------------------
void AllenVM_CPU_LIB_MATH_ADD(struct AllenInterp *i) {
AllenVM_InterpSetCommand(i,TLIB_MATH_ABS, AllenVM_CPU_LIB_MATH_ABS, NULL); // Absolute value.
AllenVM_InterpSetCommand(i,TLIB_MATH_ACC, AllenVM_CPU_LIB_MATH_ACC, NULL); // Arc cosine.
AllenVM_InterpSetCommand(i,TLIB_MATH_ACS, AllenVM_CPU_LIB_MATH_ACS, NULL); // Arc sine.
AllenVM_InterpSetCommand(i,TLIB_MATH_ACT, AllenVM_CPU_LIB_MATH_ACT, NULL); // Arc tangent.
AllenVM_InterpSetCommand(i,TLIB_MATH_AHC, AllenVM_CPU_LIB_MATH_AHC, NULL); // Hyperbolic arc cosine.
AllenVM_InterpSetCommand(i,TLIB_MATH_AHS, AllenVM_CPU_LIB_MATH_AHS, NULL); // Hyperbolic arc sine.
AllenVM_InterpSetCommand(i,TLIB_MATH_AHT, AllenVM_CPU_LIB_MATH_AHT, NULL); // Hyperbolic arc tangent.
AllenVM_InterpSetCommand(i,TLIB_MATH_BAS, AllenVM_CPU_LIB_MATH_BAS, NULL); // Base conversion.
AllenVM_InterpSetCommand(i,TLIB_MATH_CBR, AllenVM_CPU_LIB_MATH_CBR, NULL); // Cube root.
AllenVM_InterpSetCommand(i,TLIB_MATH_CIL, AllenVM_CPU_LIB_MATH_CIL, NULL); // Round value up.
AllenVM_InterpSetCommand(i,TLIB_MATH_COS, AllenVM_CPU_LIB_MATH_COS, NULL); // Cosine.
AllenVM_InterpSetCommand(i,TLIB_MATH_CSH, AllenVM_CPU_LIB_MATH_CSH, NULL); // Hyperbolic cosine.
AllenVM_InterpSetCommand(i,TLIB_MATH_DEC, AllenVM_CPU_LIB_MATH_DEC, NULL); // Decrement value.
AllenVM_InterpSetCommand(i,TLIB_MATH_EXP, AllenVM_CPU_LIB_MATH_EXP, NULL); // Exponent.
AllenVM_InterpSetCommand(i,TLIB_MATH_FLR, AllenVM_CPU_LIB_MATH_FLR, NULL); // Round value up.
AllenVM_InterpSetCommand(i,TLIB_MATH_INC, AllenVM_CPU_LIB_MATH_INC, NULL); // Increment value.
AllenVM_InterpSetCommand(i,TLIB_MATH_LOG, AllenVM_CPU_LIB_MATH_LOG, NULL); // Logarithm.
AllenVM_InterpSetCommand(i,TLIB_MATH_RAM, AllenVM_CPU_LIB_MATH_RAM, NULL); // Random number.
AllenVM_InterpSetCommand(i,TLIB_MATH_RND, AllenVM_CPU_LIB_MATH_RND, NULL); // Round to next integer.
AllenVM_InterpSetCommand(i,TLIB_MATH_SGN, AllenVM_CPU_LIB_MATH_SGN, NULL); // Sign change.
AllenVM_InterpSetCommand(i,TLIB_MATH_SIN, AllenVM_CPU_LIB_MATH_SIN, NULL); // Sine.
AllenVM_InterpSetCommand(i,TLIB_MATH_SSH, AllenVM_CPU_LIB_MATH_SSH, NULL); // Hyperbolic sine.
AllenVM_InterpSetCommand(i,TLIB_MATH_SQR, AllenVM_CPU_LIB_MATH_SQR, NULL); // Square root.
AllenVM_InterpSetCommand(i,TLIB_MATH_TAN, AllenVM_CPU_LIB_MATH_TAN, NULL); // Tangent.
AllenVM_InterpSetCommand(i,TLIB_MATH_TSH, AllenVM_CPU_LIB_MATH_TSH, NULL); // Hyperbolic tangent.
AllenVM_InterpSetCommand(i,TLIB_MATH_HLP, AllenVM_CPU_LIB_MATH_HLP, NULL); // Helper function.
}
// =====================================================================================================================================
// EOF
// =====================================================================================================================================
// Compiler parameters: Gcc -O2 -lm
// Recommended editor: Scite/Gedit/Vim.