Lua源码阅读-lmath.c

最新推荐文章于 2021-06-13 13:25:34 发布
最新推荐文章于 2021-06-13 13:25:34 发布
阅读量430 收藏
点赞数
分类专栏： Lua源码学习 文章标签： lua
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/pyf09/article/details/103917122
版权

/*
** $Id: lmathlib.c,v 1.117 2015/10/02 15:39:23 roberto Exp $
** Standard mathematical library
** See Copyright Notice in lua.h
**
** 少数函数自己实现(主要是为了兼容lua中的number可能int64而数学库中的函数可能仅能处理bit32的情况)，
*  大部分直接调用C的math库。
*/


#define lmathlib_c
#define LUA_LIB

#include "lprefix.h"

//能用已有的标准库函数就直接用
#include <stdlib.h>
#include <math.h>

#include "lua.h"

#include "lauxlib.h"
#include "lualib.h"


#undef PI
#define PI    (l_mathop(3.141592653589793238462643383279502884))


#if !defined(l_rand)        /* { */
#if defined(LUA_USE_POSIX)
#define l_rand()    random()
#define l_srand(x)    srandom(x)
#define L_RANDMAX    2147483647    /* (2^31 - 1), following POSIX */
#else
#define l_rand()    rand()
#define l_srand(x)    srand(x)
#define L_RANDMAX    RAND_MAX
#endif
#endif                /* } */

//lua配置中int可以64bit测试了下，abs只能支持32bit?故而这里采用了自己的实现方式
static int math_abs (lua_State *L) {
  if (lua_isinteger(L, 1)) {
    lua_Integer n = lua_tointeger(L, 1);
    if (n < 0) n = (lua_Integer)(0u - (lua_Unsigned)n); //这里必须对C的int转换熟悉
    lua_pushinteger(L, n);
  }
  else
    lua_pushnumber(L, l_mathop(fabs)(luaL_checknumber(L, 1)));
  return 1;
}

static int math_sin (lua_State *L) {
  lua_pushnumber(L, l_mathop(sin)(luaL_checknumber(L, 1)));
  return 1;
}

static int math_cos (lua_State *L) {
  lua_pushnumber(L, l_mathop(cos)(luaL_checknumber(L, 1)));
  return 1;
}

static int math_tan (lua_State *L) {
  lua_pushnumber(L, l_mathop(tan)(luaL_checknumber(L, 1)));
  return 1;
}

static int math_asin (lua_State *L) {
  lua_pushnumber(L, l_mathop(asin)(luaL_checknumber(L, 1)));
  return 1;
}

static int math_acos (lua_State *L) {
  lua_pushnumber(L, l_mathop(acos)(luaL_checknumber(L, 1)));
  return 1;
}

static int math_atan (lua_State *L) {
  lua_Number y = luaL_checknumber(L, 1);
  lua_Number x = luaL_optnumber(L, 2, 1);
  lua_pushnumber(L, l_mathop(atan2)(y, x));
  return 1;
}

// 尝试转换成整数
static int math_toint (lua_State *L) {
  int valid;
  lua_Integer n = lua_tointegerx(L, 1, &valid);
  if (valid)
    lua_pushinteger(L, n);
  else {
    luaL_checkany(L, 1);  //这里从语义来说，必须有一个Lua传过来的值，故而判断下
    lua_pushnil(L);  /* value is not convertible to integer */
  }
  return 1;
}

// 将d按照int或number压入栈顶(优先考虑int)
static void pushnumint (lua_State *L, lua_Number d) {
  lua_Integer n;
  if (lua_numbertointeger(d, &n))  /* does 'd' fit in an integer? */
    lua_pushinteger(L, n);  /* result is integer */
  else
    lua_pushnumber(L, d);  /* result is float */
}

//向下取整
static int math_floor (lua_State *L) {
  if (lua_isinteger(L, 1))
    lua_settop(L, 1);  /* integer is its own floor */
  else {
    lua_Number d = l_mathop(floor)(luaL_checknumber(L, 1));
    pushnumint(L, d);
  }
  return 1;
}

// 向上取整
static int math_ceil (lua_State *L) {
  if (lua_isinteger(L, 1))
    lua_settop(L, 1);  /* integer is its own ceil */
  else {
    lua_Number d = l_mathop(ceil)(luaL_checknumber(L, 1));
    pushnumint(L, d);
  }
  return 1;
}


static int math_fmod (lua_State *L) {
  if (lua_isinteger(L, 1) && lua_isinteger(L, 2)) {
    lua_Integer d = lua_tointeger(L, 2);
    if ((lua_Unsigned)d + 1u <= 1u) {  /* special cases: -1 or 0 */
      luaL_argcheck(L, d != 0, 2, "zero");
      lua_pushinteger(L, 0);  /* avoid overflow with 0x80000... / -1 */
    }
    else
      lua_pushinteger(L, lua_tointeger(L, 1) % d);
  }
  else
    lua_pushnumber(L, l_mathop(fmod)(luaL_checknumber(L, 1),
                                     luaL_checknumber(L, 2)));
  return 1;
}


/*
** next function does not use 'modf', avoiding problems with 'double*'
** (which is not compatible with 'float*') when lua_Number is not
** 'double'.
*/
static int math_modf (lua_State *L) {
  if (lua_isinteger(L ,1)) {
    lua_settop(L, 1);  /* number is its own integer part */
    lua_pushnumber(L, 0);  /* no fractional part */
  }
  else {
    lua_Number n = luaL_checknumber(L, 1);
    /* integer part (rounds toward zero) */
    lua_Number ip = (n < 0) ? l_mathop(ceil)(n) : l_mathop(floor)(n);
    pushnumint(L, ip);
    /* fractional part (test needed for inf/-inf) */
    lua_pushnumber(L, (n == ip) ? l_mathop(0.0) : (n - ip));
  }
  return 2;
}


static int math_sqrt (lua_State *L) {
  lua_pushnumber(L, l_mathop(sqrt)(luaL_checknumber(L, 1)));
  return 1;
}

//ult:unsigned less than
static int math_ult (lua_State *L) {
  lua_Integer a = luaL_checkinteger(L, 1);
  lua_Integer b = luaL_checkinteger(L, 2);
  lua_pushboolean(L, (lua_Unsigned)a < (lua_Unsigned)b);
  return 1;
}

static int math_log (lua_State *L) {
  lua_Number x = luaL_checknumber(L, 1);
  lua_Number res;
  if (lua_isnoneornil(L, 2))  // 很明显，如果第二个参数是nil或none，那么默认以2为底了
    res = l_mathop(log)(x);
  else {
    lua_Number base = luaL_checknumber(L, 2);
#if !defined(LUA_USE_C89)
    if (base == 2.0) res = l_mathop(log2)(x); else
#endif
    if (base == 10.0) res = l_mathop(log10)(x);
    else res = l_mathop(log)(x)/l_mathop(log)(base);
  }
  lua_pushnumber(L, res);
  return 1;
}

static int math_exp (lua_State *L) {
  lua_pushnumber(L, l_mathop(exp)(luaL_checknumber(L, 1)));
  return 1;
}

static int math_deg (lua_State *L) {
  lua_pushnumber(L, luaL_checknumber(L, 1) * (l_mathop(180.0) / PI));
  return 1;
}

static int math_rad (lua_State *L) {
  lua_pushnumber(L, luaL_checknumber(L, 1) * (PI / l_mathop(180.0)));
  return 1;
}

//尝试从一串参数中取最小值
static int math_min (lua_State *L) {
  int n = lua_gettop(L);  /* number of arguments */
  int imin = 1;  /* index of current minimum value */
  int i;
  luaL_argcheck(L, n >= 1, 1, "value expected");  //至少得传入一个参数
  for (i = 2; i <= n; i++) {
    if (lua_compare(L, i, imin, LUA_OPLT))
      imin = i;
  }
  lua_pushvalue(L, imin);
  return 1;
}


static int math_max (lua_State *L) {
  int n = lua_gettop(L);  /* number of arguments */
  int imax = 1;  /* index of current maximum value */
  int i;
  luaL_argcheck(L, n >= 1, 1, "value expected");
  for (i = 2; i <= n; i++) {
    if (lua_compare(L, imax, i, LUA_OPLT))
      imax = i;
  }
  lua_pushvalue(L, imax);
  return 1;
}

/*
** This function uses 'double' (instead of 'lua_Number') to ensure that
** all bits from 'l_rand' can be represented, and that 'RANDMAX + 1.0'
** will keep full precision (ensuring that 'r' is always less than 1.0.)
**
** 仔细看这个函数的实现
** l_rand()的返回范围是[0, L_RANDMAX]
*/
static int math_random (lua_State *L) {
  lua_Integer low, up;
  double r = (double)l_rand() * (1.0 / ((double)L_RANDMAX + 1.0));
  switch (lua_gettop(L)) {  /* check number of arguments */
    case 0: {  /* no arguments */
      lua_pushnumber(L, (lua_Number)r);  /* Number between 0 and 1 */
      return 1;
    }
    case 1: {  /* only upper limit */
      low = 1;
      up = luaL_checkinteger(L, 1);
      break;
    }
    case 2: {  /* lower and upper limits */
      low = luaL_checkinteger(L, 1);
      up = luaL_checkinteger(L, 2);
      break;
    }
    default: return luaL_error(L, "wrong number of arguments");
  }
  /* random integer in the interval [low, up] */
  luaL_argcheck(L, low <= up, 1, "interval is empty"); 
  luaL_argcheck(L, low >= 0 || up <= LUA_MAXINTEGER + low, 1,
                   "interval too large");
    /* 
     * 把上面的比例因子r=(0-0.99999999) 照射到[low,up]的range上 
     * 此时结果为[0, range-0.0000001)
    */
  r *= (double)(up - low) + 1.0;

    /* 
     * 此时的结果范围是[low, up+1-0.00001)
     * int取证后的范围是[low, up],且每个整数值的权值都相等
     * 巧妙利用了C函数中浮点数转整数的规则
    */
  lua_pushinteger(L, (lua_Integer)r + low);
  return 1;
}

//设置随机种子
static int math_randomseed (lua_State *L) {
  l_srand((unsigned int)(lua_Integer)luaL_checknumber(L, 1));
    
    //这里弃用第一个结果，有点小技巧
  (void)l_rand(); /* discard first value to avoid undesirable correlations */
  return 0;
}


//这个函数随带记一下
static int math_type (lua_State *L) {
  if (lua_type(L, 1) == LUA_TNUMBER) {
      if (lua_isinteger(L, 1))
        lua_pushliteral(L, "integer"); 
      else
        lua_pushliteral(L, "float"); 
  }
  else {
    luaL_checkany(L, 1);
    lua_pushnil(L);
  }
  return 1;
}


/*
** {==================================================================
** Deprecated functions (for compatibility only)
** ===================================================================
*/
#if defined(LUA_COMPAT_MATHLIB)

static int math_cosh (lua_State *L) {
  lua_pushnumber(L, l_mathop(cosh)(luaL_checknumber(L, 1)));
  return 1;
}

static int math_sinh (lua_State *L) {
  lua_pushnumber(L, l_mathop(sinh)(luaL_checknumber(L, 1)));
  return 1;
}

static int math_tanh (lua_State *L) {
  lua_pushnumber(L, l_mathop(tanh)(luaL_checknumber(L, 1)));
  return 1;
}

static int math_pow (lua_State *L) {
  lua_Number x = luaL_checknumber(L, 1);
  lua_Number y = luaL_checknumber(L, 2);
  lua_pushnumber(L, l_mathop(pow)(x, y));
  return 1;
}

static int math_frexp (lua_State *L) {
  int e;
  lua_pushnumber(L, l_mathop(frexp)(luaL_checknumber(L, 1), &e));
  lua_pushinteger(L, e);
  return 2;
}

static int math_ldexp (lua_State *L) {
  lua_Number x = luaL_checknumber(L, 1);
  int ep = (int)luaL_checkinteger(L, 2);
  lua_pushnumber(L, l_mathop(ldexp)(x, ep));
  return 1;
}

static int math_log10 (lua_State *L) {
  lua_pushnumber(L, l_mathop(log10)(luaL_checknumber(L, 1)));
  return 1;
}

#endif
/* }================================================================== */

static const luaL_Reg mathlib[] = {
  {"abs",   math_abs},
  {"acos",  math_acos},
  {"asin",  math_asin},
  {"atan",  math_atan},
  {"ceil",  math_ceil},
  {"cos",   math_cos},
  {"deg",   math_deg},
  {"exp",   math_exp},
  {"tointeger", math_toint},
  {"floor", math_floor},
  {"fmod",   math_fmod},
  {"ult",   math_ult},
  {"log",   math_log},
  {"max",   math_max},
  {"min",   math_min},
  {"modf",   math_modf},
  {"rad",   math_rad},
  {"random",     math_random},
  {"randomseed", math_randomseed},
  {"sin",   math_sin},
  {"sqrt",  math_sqrt},
  {"tan",   math_tan},
  {"type", math_type},
#if defined(LUA_COMPAT_MATHLIB)
  {"atan2", math_atan},
  {"cosh",   math_cosh},
  {"sinh",   math_sinh},
  {"tanh",   math_tanh},
  {"pow",   math_pow},
  {"frexp", math_frexp},
  {"ldexp", math_ldexp},
  {"log10", math_log10},
#endif
  /* placeholders */
  {"pi", NULL},
  {"huge", NULL},
  {"maxinteger", NULL},
  {"mininteger", NULL},
  {NULL, NULL}
};


/*
** Open math library
*/
LUAMOD_API int luaopen_math (lua_State *L) {
  /* 构建一张表，按照mathlib赋值key<---->value */
  luaL_newlib(L, mathlib);
  
  lua_pushnumber(L, PI);
  lua_setfield(L, -2, "pi");
  
  lua_pushnumber(L, (lua_Number)HUGE_VAL);
  lua_setfield(L, -2, "huge");
  
  lua_pushinteger(L, LUA_MAXINTEGER);
  lua_setfield(L, -2, "maxinteger");
  
  lua_pushinteger(L, LUA_MININTEGER);
  lua_setfield(L, -2, "mininteger");
  
  return 1;
}

shankusu2017
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
lua-5.1.4-15.el7.x86_64.rpm
11-30
离线安装包，亲测可用
lua5.3 批量注册c函数
bull521的博客
04-14 2912
cocos2d-x使用的lua版本号为5.1，使用的是luaL_register()函数来进行批量注册。下面说一下在5.3版本怎样批量注册函数。先以luaL_openlibs()函数为例。static const luaL_Reg loadedlibs[] = { {"_G", luaopen_base}, {LUA_LOADLIBNAME, luaopen_package},//pack...
干货 | LuatOS BSP移植教程，简单到复制粘贴！！！
合宙Luat官方账号
05-10 2万+
作者简介：梦程——Luat社群劳模典范、Luat训练营宝藏老师、B站科技区UP主，是一位思维敏捷而又热心分享的00后新生代科技爱好者和开发者，尤喜探索新事物。目前小梦老师正在做ESP32的LuatOS分支，特别总结经验推出本篇LuatOS BSP移植教程，方便大家快速上手。LuatOS本着自身的开源特性，可以很轻松的嵌入到很多微处理器和微控制器。今天简要讲下如何移植这套系统，上手比较简单，看完基本就会了。要想做移植，就要先了解需要移植芯片的SDK，LuatOS依赖于FreeRTOS/RTT这类RTOS系统。
LUA 源码阅读笔记（一）
zhucz333的专栏
11-08 731
好久没有在网上留言了。。。   背景介绍 因为工作的需要，后台svr要能够动态修改更新，使用C当然没有问题，问题就在于修改源码后，需要重启服务。所以就想到在C里能够嵌入一种脚本，最好是和C无缝结合的。因此就想到使用到LUA，LUA的大名圈内人士应该早有耳闻，只不过一直没有机会接触。机缘巧合，有幸一见。   俗话说得好，耳闻不如一见。LUA使用起来还是很简单的，语法和普通的脚本语言相差不大
Lua内置库的实现(一)_math模块（二）_math模块API实现
heyuchang666的专栏
04-12 1817
math模块内的各个数学函数的实现中规中矩，就是使用的Lua手册里给出的API来实现的。 Lua的扩展方式是编写一个原型为int lua_CFunction (lua_State *L)的函数。L对于使用者来说，不必关心其内部结构。实际上，公开API定义所在的lua. h中也没有lua_State的结构定义。对于一个用C编写的系统，模块化设计的重点在于接口的简洁和稳定。数据结构的细节和内存布局最好能藏在实现层面，Lua的API设计在这方面做了一个很好的示范。这个函数通常不会也不建议被C程序的其它部分直接调用
lua学习笔记（1）----lua开发环境的搭建 lua代码编译出可执行文件
jeason的博客
06-13 1592
基于linux 平台的测试 1. 获得源码 关于lua的介绍以及如何获取源码建议读者去这个网址获取 http://www.lua.org/ 1.1 linux 下的安装编译 http://www.lua.org/download.html 安装和编译的方法这里提供了，建议使用这种方法进行下载和安装。 curl -R -O http://www.lua.org/ftp/lua-5.4.3.tar.gz tar zxf lua-5.4.3.tar.gz cd lua-5.4.3 make all test
Lua源码剖析(lmathlib.c)
MaximusZhou的专栏
06-09 2759
0、该模块是Lua数学库math模块的实现，读该模块源码是为了学习Lua与C的API以及注册方法。 1、当在Lua程序中，调用require("math")时，就会调用下面的luaopen_math函数，来注册函数库：      static const luaL_Reg mathlib[] = {        {"abs",   math_abs},        {"acos",
Linux基础——（1）静态库、动态库的制作和使用
Mr.Sugarcane
03-31 187
决心重新把以前学习的Unix/linux的知识重新梳理一遍。内容比较基础，但实际也很有趣。实际上，在接触了多种语言之后，我依然坚定的认为C/C++是最有魅力的语言。所以，在我接下来的学习整理的文档中，这两种语言都会用到吧。跟我一起学习这个部分的内容的话，假设你已经掌握了C/C++的基础语法知识。 1、静态库和动态库的区别 函数库分为静态库和动态库两种。 静态库在程序编译时会被连接到目标...
Lua源码分析 - 基础篇 - Lua源码的结构和架构图（01）
热门推荐
自娱自乐的代码人
11-26 2万+
很久很久没有写博客了，一直忙于工作和项目，最近依然想静下来阅读一些好的源码。自从读完了Nginx和Memcache的源码后，对服务器端的基础开源软件的实现原理有了一定的认识，接下来想看看Lua这门精巧的语言是如何实现的。 开启Lua源码阅读之旅 Lua是一门用C语言编写的脚本语言，一共1w多行代码，非常的轻巧，适合做web脚本、游戏脚本、物联网等场景下使用。 Lua可以进行独立编程，但是大部...
lua源代码分析01：lua源代码结构分析
魏波
03-12 5981
“标题1”第三方
Lua源码分析(3) -- 虚拟机
INmouse -- Young decide by you self
03-28 2万+
Lua首先将源程序编译成为字节码,然后交由虚拟机解释执行.对于每一个函数,Lua的编译器将创建一个原型(prototype),它由一组指令及其使用到的常量组成[1].最初的Lua虚拟机是基于栈的.到1993年,Lua5.0版本,采用了基于寄存器的虚拟机,使得Lua的解释效率得到提升,体系结构与指令系统 与虚拟机和指令相关的文件主要有两个: lopcodes.c 和 lvm.c. 从名称可以
EmmyLua-AttachDebugger-1.0.0.4.zip
08-12
EmmyLua-AttachDebugger-1.0.0.4 最新intellij 断点调试
IntelliJ-EmmyLua-1.2.6-IDEA172.zip
03-09
对应IntelliJ IDEA 2018.1版本，对应升级后无法Attach Debugger的问题
lua-language-server2.3.7.zip
09-14
安装lua-language-server 可以用于nvim中lua代码自动补全 使用方法可参考文章： https://blog.csdn.net/lxyoucan/article/details/120292520
lua-devel-5.1.4-4.1.el6.x86_64.rpm
05-31
安装nginx_lua模块时候需要先安装nginx的依赖包，安装命令rpm -ivh lua-devel-5.1.4-4.1.el6.x86_64.rpm
Lua5.3——C API函数
lgy101024的博客
04-13 889
原创 2016年07月18日 18:00:442941看了三四天的Lua API，虽然有些没能理解，但是收获还是颇丰的，那么下面我将以我自己的方式把C API重新整理归纳一下。一、前言这里按字母次序列出了所有C API中的函数和类型。每个函数都有一个这样的提示：                      [-o, +p, x]对于第一个域，o，指的是该函数会从栈上弹出多少个元素。第二个域，p，指该...
Lua源码学习-lmathlib.c
Shanks
06-27 197
/* ** $Id: lmathlib.c,v 1.117 2015/10/02 15:39:23 roberto Exp $ ** Standard mathematical library ** See Copyright Notice in lua.h ** ** 少数函数自己实现(主要是为了兼容lua中的number可能int64而数学库中的函数可能仅能处理bit32的情况)， * 大部分直接调用C的math库。 */ #define lmathlib_c #define LUA_LIB #.
Lua源码揭秘（二）一个简单的数学扩展库函数
凯奥斯的注释
10-28 1282
之前遇到过一个问题，在我们的游戏中大量使用了atan方法，但是atan的方法太费了，所以我们使用了泰勒展开式来求一个近似值。 arctan的泰勒展开式为： arctan(x)=x−13x3+15x5−17x7⋯+(−1)n−12n−1x2n−1arctan(x)=x-\frac{1}{3}x^3+\frac{1}{5}x^5-\frac{1}{7}x^7\cdots+\frac{{(-1)}^{
lua数学库LuaMathLib
Teng's world
09-15 1683
实在厌倦了做了多个游戏项目之后，对常用的数学计算总是算了又忘忘了再算。与其他技术问题相比，一个解决一个数学型问题有着费时、不易调试逻辑错误、边界条件不明显有隐患、没成就感等特点。本着坑不能踩n+1次的心态，我做了这个东西——LuaMathLib。 今天的主角是LuaMathLib，一个通用可移植的纯Lua数学库。 语言层面上的特点 面向对象 即封装、实例化那堆术语了，目的是在任何面向
lua-devel-5.3.4-10.el8.x86_64.rpm
最新发布
10-30
此外，这个软件包还包含了开发Lua C扩展所需的相关头文件和库文件，可以方便地扩展Lua语言的功能。 要安装lua-devel-5.3.4-10.el8.x86_64.rpm，可以使用CentOS 8操作系统上的.rpm软件包管理器（如yum）执行相应的...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值