自己写的一个数学库

最新推荐文章于 2022-03-02 22:23:36 发布
最新推荐文章于 2022-03-02 22:23:36 发布
阅读量1k 收藏
点赞数 1
分类专栏： acm
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/lisc741/article/details/8684624
版权

因为要做光线跟踪，所以要有一个自己的图形库嘛，所以要封装自己的数学库，所以我就模仿者书上写了一个图形库

按它的那个库中的函数写的，名字大多都一样，有些我认为可以优化的优化了一下

BkDefs.h  定义一些数据姐都的

#ifndef BKDEFS_H_INCLUDED
#define BKDEFS_H_INCLUDED
/*包含定义的常量及数据类型*/

typedef unsigned char Byte  ;
typedef unsigned int  Word  ;
typedef unsigned long DWord ;
//typedef enum { false , true  } Boolen ;
typedef char Name[80] ;

typedef struct {
    Byte Red ;
    Byte Grn ;
    Byte Blu ;
} RGB ;

typedef RGB Palette_Register[256] ;
typedef float TDA[3]  ;                     //实数三维向量
typedef float FDA[4]  ;                     //实数四维向量
typedef int   TDIA[3] ;                     //整数三维向量
typedef float Matx4x4[4][4] ;               //实数的4x4矩阵
#define MaxCol      7
#define MaxInten    35
#define Ln10        2.30258509299405E+000
#define OneOverLn10 0.43429448190325E+000
#define Pi          3.1415927
#define PiOver180   1.74532925199433E-002
#define PiUnder180  5.72957795130823E+001

#endif // BKDEFS_H_INCLUDED

BkMath.h声明函数

#ifndef BKMATH_H_INCLUDED
#define BKMATH_H_INCLUDED

/*包含数学模块各例程使用的函数原型,这些原型指明指明数学*/
/*模块中所有函数的名字和参数，以及需要向函数传入的参数*/

#include "BkDefs.h"
/*基本数学函数*/

/*Round( x ) : 返回与x最接近的整数*/
extern int   Round( double x ) ;

/*Frac(x) : 返回x的小数部分，如果x < 0 ,Frac( x ) = x-Trunc( x )*/
extern float Frac ( double x ) ;

/*Trunc( x ) : 返回x的整数部分，舍去小数部分*/
extern int   Trunc( double x ) ;

/*SqrFP( x ) : 返回浮点数x的平方*/
extern float SqrFp( float  x ) ;

/*Sqr( x ) : 返回整数x的平方*/
extern int   Sqr  ( int    x ) ;

/*Radians( Angle ) ：返回以弧度表示的Angle*/
extern float Radians( float Angle ) ;

/*Degrees( Angle ) ：返回以角度表示的Angle*/
extern float Degrees( float Angle ) ;

/*描述数学函数的cos函数,接收角度Angle*/
extern float CosD( float Angle ) ;

/*描述数学函数的sin函数,接收角度Angle*/
extern float SinD( float Angle ) ;

/*求Base的Exponent次幂*/
extern float Power( float Base , int Exponent ) ;

/*求一个数以10为底的对数*/
extern float Log   ( float x ) ;

/*计算以10为底的实数次幂*/
extern float Exp10 ( float x ) ;

/*获取浮点数的符号*/
extern float Sign  ( float x ) ;

/*获取传入参数的符号，传入参数为整数*/
extern int   IntSign ( int x ) ;

/*计算一个整数x的平方根，并返回与结果最接近的整数*/
extern int   IntSqrt ( int x ) ;

/*IntPower使用递归计算整数的整数次幂,Base的Exponent次幂*/
extern int   IntPower( int x ) ;

/*返回两个浮点数里的最小数*/
extern float MIN( float a , float b ) ;

/*返回两个浮点数里的最大数*/
extern float MAX( float a , float b ) ;

/*返回三个浮点数里的最小数*/
extern float MIN3( float a , float b , float c ) ;

/*返回三个浮点数里的最大数*/
extern float MAX3( float a , float b , float c ) ;

/*返回四个浮点数里的最小数*/
extern float MIN4( float a , float b , float c , float d ) ;

/*返回四个浮点数里的最大数*/
extern float MAX4( float a , float b , float c , float d ) ;

/*向量和矩阵函数*/

/*创建浮点数三维向量TDA*/
extern void  Vec ( float r , float s , float t , TDA   A ) ;

/*创建整数数三维向量TDIA*/
extern void  VecInt( int r , int s , int t , TDIA A ) ;

/*提取存储在TDA里的三个浮点值*/
extern void  UnVec( TDA A , float *r , float *s , float *t) ;

/*提取存储在TDIA里的三个浮点值*/
extern void  UnVecInt( TDIA A , int *r , int *s , int *t ) ;

/*计算向量A与向量B的点积*/
extern float VecDot( TDA A , TDA B ) ;

/*计算向量A与向量B的叉积*/
extern void  VecCross( TDA A , TDA B , TDA C ) ;

/*计算向量的模长*/
extern float VecLen( TDA A ) ;

/*规格化向量A,即使A的模长为1*/
extern void  VecNormalize( TDA A ) ;

/*将一个实数四维向量A与一个变换矩阵Matrix相乘,存入实数四维向量B*/
extern void  VecMatxMult( FDA A , Matx4x4 Matrix , FDA B ) ;

/*对实数三维向量A-B求值,结果存入实数三维向量C*/
extern void  VecSub( TDA A , TDA B , TDA C ) ;

/*对整数向量A-B求值,结果存入实数向量C*/
extern void  VecSubInt( TDIA A , TDIA B , TDA C ) ;

/*对实数三维向量A+B求值,结果存入实数向量C*/
extern void  VecAdd( TDA A , TDA B , TDA C ) ;

/*对整数向量A+B求值,结果存入实数向量C*/
extern void  VecAdd3( TDA A , TDA B , TDA C , TDA D ) ;

/*对实数向量A+B求值,结果存入实数向量C*/
extern void  VecCopy( TDA A , TDA B ) ;

/*将向量三维实数A复制到三维实数B*/
extern void  VecCopyInt( TDIA A , TDIA B ) ;

/*将三维整数向量A复制到三维整数向量B*/
extern void  VecLinComb( float r , TDA A , float s , TDA B , TDA C ) ;

/*计算向量A与向量B的线性组合：C = rA + sB 结果存入三维实数向量C*/
extern void  VecScalMult ( float r , TDA  A , TDA B ) ;

/*缩放运算，将传入三维实数向量A与给定实数r相乘 ， 结果存入三维实数向量B*/
extern void  VecScalMultI( float r , TDIA A , TDA B ) ;

/*缩放运算，将传入三维整数向量A与给定实数r相乘 ， 结果存入三维实数向量B*/
extern void  VecScalMultInt( float r , TDA A , TDIA B ) ;

/*将传入的三维实数向量A与实数r相乘，执行缩放操作, 再与三维实数向量B相加，结果存入三维实数向量C*/
extern void  VecAddScalMult( float r , TDA A , TDA B , TDA C ) ;

/*将所有三维实数向量A内各元素置为0*/
extern void  VecNull( TDA A ) ;

/*将所有三维整数向量A内各元素置为0*/
extern void  VecNullInt( TDIA A ) ;

/*三维实数向量A乘B再与实数r相乘，最后保存在三维实数向量C内*/
extern void  VecElemMult( float r , TDA A , TDA B , TDA C ) ;

/*查找向量的最小分量*/
extern void  VecMin( TDA a , TDA b , TDA c ) ;

/*查找向量的最大分量*/
extern void  VecMax( TDA a , TDA b , TDA c ) ;

/*通过改变元素符号，使向量反向*/
extern void  VecNegate( TDA A ) ;

/*仿射变换函数*/

/*将4x4向量所有元素置0*/
extern void  ZeroMatrix( Matx4x4 A ) ;

/*平移矩阵，沿向量( tx , ty , tz )反向平移  , 将该平移矩阵存入A */
extern void  Translate3D( float tx , float ty , float tz , Matx4x4 A ) ;

/*缩放矩阵, 在 x 和 y 和 z 方向 ，分别缩放sx , sy , sz 倍 , 将该缩放矩阵存入A*/
extern void  Scale3D( float sx , float sy , float sz , Matx4x4 A ) ;

/*旋转矩阵,沿任意坐标轴旋转Theta角度 ， m = 1 : x轴， m = 2 : y轴， m = 3 : z轴, 将该旋转矩阵存入A**/
extern void  Rotate3D( int m , float Theta , Matx4x4 A ) ;

/*两个实数4x4矩阵乘法, 将该乘法矩阵存入A*/
extern void  Multiply3DMatricies( Matx4x4 A , Matx4x4 B , Matx4x4 C ) ;

/*将给定的矩阵a复制给矩阵b*/
extern void  MatCopy( Matx4x4 a , Matx4x4 b ) ;

/*按缩放，旋转，平移方式相乘各矩阵， 得到复合矩阵存入XForm*/
extern void  PrepareMatrix( float Tx , float Ty , float Tz ,
                            float Sx , float Sy , float Sz ,
                            float Rx , float Ry , float Rz ,
                            Matx4x4 XForm ) ;

/*本函数是用来还原函数PrepareMatrix(),本函数的参数里，*/
/*平移和旋转参数是函数PrepareMatrix里参数的相反数，而缩放参数，则是PrepareMatrix里的倒数*/
extern void  PrepareInvMatrix( float Tx , float Ty , float Tz ,
                               float Sx , float Sy , float Sz ,
                               float Rx , float Ry , float Rz ,
                               Matx4x4 XForm ) ;

/*将一个实数三维向量A与一个实数4*4矩阵M相乘，结果存入B*/
extern void  Transform( TDA A , Matx4x4 M , TDA B ) ;

/*伪随机数生成*/

/*使用一个实数初始化随机数生成器，OldSeed置为传入*/
/*的种子值,使用Rand和RandInt函数时，都必须调用InitRand函数*/
extern void  InitRand( float Seed ) ;

/*返回一个正整型随机数，范围由两字节参数Range指定*/
/*或者是从0到(Range-1)*/
extern int   RandInt ( Word Range ) ;

/*返回一个0.0到1.0之间的正实数随机数,OldRand*/
/*是常量sigma与OldRand之间的小数部分*/
/*使用Rand函数之前，必须调用InitRand函数*/
extern float Rand() ;
#endif // BKMATH_H_INCLUDED


BkMath.cpp 定义这些函数

/*函数Sign返回值是否改为int*/

#include <cstdio>
#include <cstdlib>
#include <cmath>

#include "BkMath.h"


/*********************/
/*   基本数学函数    */
/*********************/

/*Round( x ) : 返回与x最接近的整数*/
int  Round( double x )
{
    return ( ( int ) ( x + 0.5 ) ) ;
}

/*Trunc( x ) : 返回x的整数部分，舍去小数部分*/
int  Trunc( double x )
{
    return ( ( int ) ( x ) ) ;
}

/*Frac(x) : 返回x的小数部分，如果x < 0 ,Frac( x ) = x-Trunc( x )*/
float Frac( double x )
{
    int y ;
    y = ( ( int ) ( x ) ) ;
    return ( x - ( float ) y ) ;
}

/*SqrFP( x ) : 返回浮点数x的平方*/
float SqrFP( float x )
{
    return ( x * x ) ;
}

/*Sqr( x ) : 返回整数x的平方*/
int Sqr( int x )
{
    return ( x * x ) ;
}

/*Radians( Angle ) ：返回以弧度表示的Angle*/
float Radians( float Angle )
{
    return ( Angle * PiOver180 ) ;
}

/*Degrees( Angle ) ：返回以角度表示的Angle*/
float Degrees( float Angle )
{
    return ( Angle * PiUnder180 ) ;
}

/*描述数学函数的cos函数,接收角度Angle*/
float CosD( float Angle )
{
    return ( cos( Radians( Angle ) ) ) ;
}

/*描述数学函数的sin函数,接收角度Angle*/
float SinD( float Angle )
{
    return ( sin( Radians( Angle ) ) ) ;
}

/*求Base的Exponent次幂*/
float Power( float Base , float Exponent )
{
    float BPower ;
    if( Exponent == 0 ) return 1 ;
    else {
        BPower = 1.0 ;
        for( int i = 1 ; i <= Exponent ; i ++ )
            BPower *= Base ;
        return BPower ;
    }
}

/*求一个数以10为底的对数*/
float Log( float x )
{
    return ( log(x) * OneOverLn10 ) ;
}

/*计算以10为底的实数次幂*/
float Exp10( float x )
{
    return( exp( x * Ln10 ) ) ;
}

/*获取浮点数的符号*/
float Sign( float x )
{
    if( x < 0 ) return -1 ;
    else if( x > 0 ) return 1 ;
    else return 0 ;
}

/*获取传入参数的符号，传入参数为整数*/
int  IntSign( int x )
{
    if( x < 0 ) return -1 ;
    else if( x > 0 ) return 1 ;
    else return 0 ;
}

/*计算一个整数x的平方根，并返回与结果最接近的整数*/
int  IntSqrt( int x )
{
    int  OddInt = 1 , OldArg = x , FirstSqrt ;
    while( x >= 0 ) {
        x -= OddInt ;
        OddInt += 2 ;
    }
    FirstSqrt = OddInt >> 1 ;
    if( Sqr( FirstSqrt ) - FirstSqrt + 1 > OldArg )
        return ( FirstSqrt - 1 ) ;
    else return FirstSqrt ;
}

/*IntPower使用递归计算整数的整数次幂,Base的Exponent次幂*/
int  IntPower( int Base , int Exponent )
{
    int BPower ;
    if( Exponent == 0 ) return 1 ;
    else {
        BPower = 1 ;
        for( int i = 1 ; i <= Exponent ; i ++ )
            BPower *= Base ;
        return BPower ;
    }
}

/*返回两个浮点数里的最小数*/
float MIN( float a , float b )
{
    if( a < b ) return a ;
    else return b ;
}

/*返回两个浮点数里的最大数*/
float MAX( float a , float b )
{
    if( a < b ) return b ;
    else return a ;
}

/*返回三个浮点数里的最小数*/
float MIN3( float a , float b , float c )
{
    float t = MIN( a , b ) ;
    return MIN( t , c ) ;
}

/*返回三个浮点数里的最大数*/
float MAX3( float a , float b , float c )
{
    float t = MAX( a , b ) ;
    return MAX( t , c ) ;
}

/*返回四个浮点数里的最小数*/
float MIN4( float a , float b , float c , float d )
{
    float t = MIN3( a , b , c ) ;
    return MIN( t , d ) ;
}

/*返回四个浮点数里的最大数*/
float MAX4( float a , float b , float c , float d )
{
    float t = MAX3( a , b , c ) ;
    return MAX( t , c ) ;
}

/****************************/
/*      向量和矩阵函数      */
/****************************/

/*创建浮点数三维向量TDA*/
void  Vec( float r , float s , float t , TDA A )
{
    A[0] = r ; A[1] = s ; A[2] = t ;
}

/*创建整数数三维向量TDIA*/
void  VecInt( int r , int s , int t , TDIA A )
{
    A[0] = r ; A[1] = s ; A[2] = t ;
}

/*提取存储在TDA里的三个浮点值*/
void  UnVec( TDA A , float *r , float *s , float *t )
{
    *r = A[0] ; *s = A[1] ; *t = A[2] ;
}

/*提取存储在TDIA里的三个浮点值*/
void  UnVecInt( TDIA A , int *r , int *s , int *t )
{
    *r = A[0] ; *s = A[1] ; *t = A[2] ;
}

/*计算向量A与向量B的点积*/
float VecDot( TDA A , TDA B )
{
    return ( A[0] * B[0] + A[1] * B[1] + A[2] * B[2] ) ;
}

/*计算向量A与向量B的叉积*/
void  VecCross( TDA A , TDA B , TDA C )
{
    C[0] = A[1] * B[2] - A[2] * B[1] ;
    C[1] = A[2] * B[0] - A[0] * B[2] ;
    C[2] = A[0] * B[1] - A[1] * B[0] ;
}

/*计算向量的模长*/
float  VecLen( TDA A )
{
    return ( sqrt( SqrFP( A[0] ) ) + SqrFP( A[1] ) + SqrFP( A[2] ) ) ;
}

/*规格化向量A,即使A的模长为1*/
void  VecNormalize( TDA A )
{
    float  dist , invdist ;
    dist = VecLen( A ) ;
    if( !( dist == 0.0 ) )
    {
        invdist = 1.0 / dist ;
        A[0] *= invdist ;
        A[1] *= invdist ;
        A[2] *= invdist ;
    }
    else
    {
        puts( "Zero-Length Vectors cannot be Normalize" ) ;
        exit( 1 ) ;
    }
}

/*将一个实数四维向量A与一个变换矩阵Matrix相乘,存入实数四维向量B*/
void  VecMatxMult( FDA A , Matx4x4 Matrix , FDA B )
{
    for( int i = 0 ; i < 4 ; i ++ )
    {
        B[i] = 0 ;
        for( int j = 0 ; j < 4 ; j ++ )
            B[i] += A[j] * Matrix[j][i] ;
    }
}

/*对实数三维向量A-B求值,结果存入实数三维向量C*/
void  VecSub( TDA A , TDA B , TDA C )
{
    C[0] = A[0] - B[0] ;
    C[1] = A[1] - B[1] ;
    C[2] = A[2] - B[2] ;
}

/*对整数向量A-B求值,结果存入实数向量C*/
void  VecSubInt( TDIA A , TDIA B , TDA C )
{
    C[0] = float ( A[0] - B[0] ) ;
    C[1] = float ( A[1] - B[1] ) ;
    C[2] = float ( A[2] - B[2] ) ;
}

/*对实数三维向量A+B求值,结果存入实数向量C*/
void  VecAdd( TDA A , TDA B , TDA C )
{
    C[0] = A[0] + B[0] ;
    C[1] = A[1] + B[1] ;
    C[2] = A[2] + B[2] ;
}

/*对整数向量A+B求值,结果存入实数向量C*/
void  VecAddInt( TDIA A , TDIA B , TDA C )
{
    C[0] = float ( A[0] + B[0] ) ;
    C[1] = float ( A[1] + B[1] ) ;
    C[2] = float ( A[2] + B[2] ) ;
}

/*对实数向量A+B求值,结果存入实数向量C*/
void  VecAdd3( TDA A , TDA B , TDA C , TDA D)
{
    D[0] =  A[0] + B[0] +C[0] ;
    D[1] =  A[1] + B[1] +C[1] ;
    D[2] =  A[2] + B[2] +C[2] ;
}

/*将向量三维实数A复制到三维实数B*/
void  VecCopy( TDA A , TDA B )
{
    B[0] = 0.0 + A[0] ;
    B[1] = 0.0 + A[1] ;
    B[2] = 0.0 + A[2] ;
}

/*将三维整数向量A复制到三维整数向量B*/
void  VecCopyInt( TDIA A , TDIA B )
{
    B[0] = A[0] ; B[1] = A[1] ; B[2] = A[2] ;
}

/*计算向量A与向量B的线性组合：C = rA + sB 结果存入三维实数向量C*/
void  VecLinComb( float r , TDA A , float s , TDA B , TDA C )
{
    C[0] = r * A[0] + s * B[0] ;
    C[1] = r * A[1] + s * B[1] ;
    C[2] = r * A[2] + s * B[2] ;
}

/*缩放运算，将传入三维实数向量A与给定实数r相乘 ， 结果存入三维实数向量B*/
void  VecScalMult( float r , TDA A , TDA B )
{
    B[0] = r * A[0] ;
    B[1] = r * A[1] ;
    B[2] = r * A[2] ;
}

/*缩放运算，将传入三维整数向量A与给定实数r相乘 ， 结果存入三维实数向量B*/
void  VecScalMultI( float r , TDIA A , TDA B )
{
    B[0] = r * ( float ( A[0] ) ) ;
    B[1] = r * ( float ( A[1] ) ) ;
    B[2] = r * ( float ( A[2] ) ) ;
}

/*缩放运算，将传入三维实数向量A与给定实数r相乘 ， 结果存入三维整数向量B*/
void  VecScalMultInt( float r , TDA A , TDIA B )
{
    B[0] = Round( r * A[0] ) ;
    B[1] = Round( r * A[1] ) ;
    B[2] = Round( r * A[2] ) ;
}

/*将传入的三维实数向量A与实数r相乘，执行缩放操作, 再与三维实数向量B相加，结果存入三维实数向量C*/
void  VecAddScalMult( float r , TDA A , TDA B , TDA C )
{
    C[0] = r * A[0] + B[0] ;
    C[1] = r * A[1] + B[1] ;
    C[2] = r * A[2] + B[2] ;
}

/*将所有三维实数向量A内各元素置为0*/
void  VecNull( TDA A )
{
    A[0] = 0.0 ; A[1] = 0.0 ; A[2] = 0.0 ;
}

/*将所有三维整数向量A内各元素置为0*/
void  VecNullInt( TDIA A )
{
    A[0] = 0 ; A[1] = 0 ; A[2] = 0 ;
}

/*三维实数向量A乘B再与实数r相乘，最后保存在三维实数向量C内*/
void  VecElemMult( float r , TDA A , TDA B , TDA C )
{
    C[0] = r * A[0] * B[0] ;
    C[1] = r * A[1] * B[1] ;
    C[2] = r * A[2] * B[2] ;
}

/*查找向量的最小分量*/
void  VecMin( TDA a , TDA b , TDA c )
{
    if( a[0] < b[0] ) c[0] = a[0] ;
    else c[0] = b[0] ;
    if( a[1] < b[1] ) c[1] = a[1] ;
    else c[1] = b[1] ;
    if( a[2] < b[2] ) c[2] = a[2] ;
    else c[2] = b[2] ;
}

/*查找向量的最大分量*/
void  VecMax( TDA a , TDA b , TDA c )
{
    if( a[0] > b[0] ) c[0] = a[0] ;
    else c[0] = b[0] ;
    if( a[1] > b[1] ) c[1] = a[1] ;
    else c[1] = b[1] ;
    if( a[2] > b[2] ) c[2] = a[2] ;
    else c[2] = b[2] ;
}

/*通过改变元素符号，使向量反向*/
void  VecNegate( TDA A )
{
    A[0] = -A[0] ;
    A[1] = -A[1] ;
    A[2] = -A[2] ;
}

/********************/
/*   仿射变换函数   */
/********************/

/*将4x4向量所有元素置0*/
void  ZeroMatrix( Matx4x4 A )
{
    for( int i = 0 ; i < 4 ; i ++ )
    {
        for( int j = 0 ; j < 4 ; j ++ )
            A[i][j] = 0 ;
    }
}

/*平移矩阵，沿向量( tx , ty , tz )反向平移  , 将该平移矩阵存入A */
void  Translate3D( float tx , float ty , float tz , Matx4x4 A )
{
    ZeroMatrix( A ) ;
    for( int i = 0 ; i < 4 ; i ++ )
        A[i][i] = 1.0 ;
    A[0][3] = -tx ;
    A[1][3] = -ty ;
    A[2][3] = -tz ;
}

/*缩放矩阵, 在 x 和 y 和 z 方向 ，分别缩放sx , sy , sz 倍 , 将该缩放矩阵存入A*/
void  Scale3D( float sx , float sy , float sz , Matx4x4 A )
{
    ZeroMatrix( A ) ;
    A[0][0] = sx  ;
    A[1][1] = sy  ;
    A[2][2] = sz  ;
    A[3][3] = 1.0 ;
}

/*旋转矩阵,沿任意坐标轴旋转Theta角度 ， m = 1 : x轴， m = 2 : y轴， m = 3 : z轴, 将该旋转矩阵存入A**/
void  Rotate3D( int m , float Theta , Matx4x4 A )
{
    int  m1 , m2 ;
    float c , s ;
    ZeroMatrix( A ) ;
    A[m-1][m-1] = 1.0 ;
    A[3][3] = 1.0 ;
    m1 = ( m % 3 ) + 1 ;
    m2 = ( m1 % 3 ) ;
    m1 -= 1 ;
    c = CosD( Theta ) ;
    s = SinD( Theta ) ;
    A[m1][m1] = c  ;
    A[m1][m2] = s  ;
    A[m2][m2] = c  ;
    A[m2][m1] = -s ;
}

/*两个实数4x4矩阵乘法, 将该乘法矩阵存入A*/
void  Multiply3DMatricies( Matx4x4 A , Matx4x4 B , Matx4x4 C )
{
    Byte i , j , k ;
    float ab ;
    for( i = 0 ; i < 4 ; i ++ )
    {
        for( j = 0 ; j < 4 ; j ++ )
        {
            ab = 0 ;
            for( k = 0 ; k < 4 ; k ++ )
                ab += A[i][k] + B[k][j] ;
            C[i][j] = ab ;
        }
    }
}

/*将给定的矩阵a复制给矩阵b*/
void  MatCopy( Matx4x4 a , Matx4x4 b )
{
    Byte i , j ;
    for( i = 0 ; i < 4 ; i ++ )
        for( j = 0 ; j < 4 ; j ++ )
            b[i][j] = a[i][j] ;
}

/*按缩放，旋转，平移方式相乘各矩阵， 得到复合矩阵存入XForm*/
void  PrepareMatrix( float Tx , float Ty , float Tz , float Sx , float Sy , float Sz ,
                     float Rx , float Ry , float Rz , Matx4x4 XForm )
{
    Matx4x4 M1 , M2 , M3 , M4 , M5 , M6 , M7 , M8 , M9 ;
    Scale3D( Sx , Sy , Sz , M1 ) ;
    Rotate3D( 1 , Rx , M2 ) ;
    Rotate3D( 2 , Ry , M3 ) ;
    Rotate3D( 3 , Rz , M4 ) ;
    Translate3D( Tx , Ty , Tz , M5 ) ;
    Multiply3DMatricies( M2 , M1 , M6 ) ;
    Multiply3DMatricies( M3 , M6 , M7 ) ;
    Multiply3DMatricies( M4 , M7 , M8 ) ;
    Multiply3DMatricies( M5 , M8 , M9 ) ;
    MatCopy( M9 , XForm ) ;
}

/*本函数是用来还原函数PrepareMatrix(),本函数的参数里，*/
/*平移和旋转参数是函数PrepareMatrix里参数的相反数，而缩放参数，则是PrepareMatrix里的倒数*/
void  PrepareInvMatrix( float Tx , float Ty , float Tz , float Sx , float Sy , float Sz ,
                     float Rx , float Ry , float Rz , Matx4x4 XForm )
{
    Matx4x4 M1 , M2 , M3 , M4 , M5 , M6 , M7 , M8 , M9 ;
    Scale3D( Sx , Sy , Sz , M1 ) ;
    Rotate3D( 1 , Rx , M2 ) ;
    Rotate3D( 2 , Ry , M3 ) ;
    Rotate3D( 3 , Rz , M4 ) ;
    Translate3D( Tx , Ty , Tz , M5 ) ;
    Multiply3DMatricies( M4 , M5 , M6 ) ;
    Multiply3DMatricies( M3 , M6 , M7 ) ;
    Multiply3DMatricies( M2 , M7 , M8 ) ;
    Multiply3DMatricies( M1 , M8 , M9 ) ;
    MatCopy( M9 , XForm ) ;
}

/*将一个实数三维向量A与一个实数4*4矩阵M相乘，结果存入B*/
void  Transform( TDA A , Matx4x4 M , TDA B )
{
    B[0] = M[0][0] * A[0] + M[0][1] * A[1] + M[0][2] * A[2] + M[0][3] ;
    B[1] = M[1][0] * A[0] + M[1][1] * A[1] + M[1][2] * A[2] + M[1][3] ;
    B[2] = M[2][0] * A[0] + M[2][1] * A[1] + M[2][2] * A[2] + M[2][3] ;
}

/********************/
/*   伪随机数生成   */
/********************/

/*种子*/
double OldRand ;

/*伪随机数生成*/

/*使用一个实数初始化随机数生成器，OldRand置为传入*/
/*的种子值,使用Rand和RandInt函数时，都必须调用InitRand函数*/
void  InitRand( float Seed )
{
    OldRand = Seed ;
}

/*返回一个正整型随机数，范围由两字节参数Range指定*/
/*或者是从0到(Range-1)*/
int   RandInt( Word Range )
{
    float sigma = 423.1966 ;
    OldRand = Frac( sigma * OldRand ) ;
    return ( Trunc( OldRand * ( float ) Range ) ) ;
}

/*返回一个0.0到1.0之间的正实数随机数,OldRand*/
/*是常量sigma与OldRand之间的小数部分*/
/*使用Rand函数之前，必须调用InitRand函数*/
float Rand()
{
    float sigma = 423.1966 ;
    OldRand = Frac( sigma * OldRand ) ;
    return OldRand ;
}

我居然写完了之后让WD来测试，然后他具体些注释，我太邪恶了

 

以后还会把图形库一起封装的。。。

吾等前方绝无敌手
关注
专栏目录
《英雄编程体验课》第 15 课 | C语言中的数学库
英雄哪里出来
07-05 5万+
C语言中的数学库
C++中的数学函数汇总
weixin_33890526的博客
05-30 482
math.h 数学函数库,一些数学计算的公式的具体实现是放在math.h里,具体有：1 三角函数double sin (double);double cos (double);double tan (double);2 反三角函数double asin (double); 结果介于[-PI/2, PI/2]double acos (double); 结果介于[0, PI]double atan (...
Math3D:使用SSE指令实现3d游戏所需的数学功能的库很小
05-14
Math3D 我未来的游戏引擎的小库，使用SSE内在函数实现有用的数学函数和结构，例如矩阵/向量。 [==========] Running 32 tests from 4 test cases. [----------] Global test environment set-up. [----------] 10 tests from Vector4Test [ RUN ] Vector4Test.Creation [ OK ] Vector4Test.Creation (0 ms) [ RUN ] Vector4Test.SumByFloat [ OK ] Vector4Test.SumByFloat (0 ms) [ RUN ] Vector4Test.SubByFloat [ OK ]
Chaos on Graphics About 数学库之一　SSE/SSE2
派的无理性
09-02 2162
Chaos on GraphicsAbout 数学库之一　SSE/SSE2 Chaos Chiao  毫无疑问，数学库是图形程序的基石，是图形程序运行效率的关键之一。一个优秀的数学库可以让图形程序运行得更流畅，甚至要快上几十倍上百倍。有时候替换一条除法运算会带来成倍的效率增长，比如用乘以 1/op 替换 vector 里的 operator /。当然，更高级的优化是使用 S
（算法设计与分析）实验一 编写自己的数学库
weixin_44209522的博客
06-13 1403
一、实验目的 利用微积分知识和C/C++语言，扩展计算能力，实现自己的函数库。 二、 实验要求 1） 泰勒展开式为如下形式： 2） 利用泰勒展开式完成如下函数，并与系统库math.h中的对应函数比较性能。 至少实现以上4个函数，可以自己实现更多初等函数。 三、实验步骤与内容 代码： #include <iostream> #include <windows.h> #include <math.h> #define pi 3.1415926 #define e 2.
我自己写的3D图形数学库。。。有点乱！
daojin505的专栏
08-07 610
// Det.cpp : Defines the entry point for the console application. // #include "stdafx.h" #define M 3//矩阵大小 #include #include #include #include #include #include "ArrayInterTriangle.h"
数学库中应用SSE之一
06-09 1017
<br /><br />引自：http://hi.baidu.com/sige_online/blog/item/d8fdfffc8f0033f7fd037fac.html<br /> <br />毫无疑问，数学库是图形程序的基石，是图形程序运行效率的关键之一。一个优秀的数学库可以让图形程序运行得更流畅，甚至要快上几十倍上百倍。有时候替换一条除法运算会带来成倍的效率增长，比如用乘以 1/op 替换 vector 里的 operator /。当然，更高级的优化是使用 SIMD 优化海量运算，这就是本文的中心—
VHDL数学运算库1.0.zip_vhdl 数学_vhdl 数学库_vhdl 设计 _数学运算
09-23
描述中提到“这是一个VHDL写的数学运算的硬件设计库，还算比较完整”，这暗示了该库可能包含了各种基本和高级的数学运算模块，例如加法、减法、乘法、除法，以及可能的矩阵运算、傅立叶变换等。一个完整的库通常会...
tinyvec2.js:适用于JavaScript的微型2D矢量数学库
05-18
我发现自己写过很多类似的文章，无论是向同伴解释矢量数学时，还是作为我不想处理依赖关系的快速实验的一部分。 虽然我每次都喜欢编写向量数学函数，但有时我真正需要构建的东西的开发动力却迷失了。 我写了这段...
spacetime.js:[已取消]一个用于数学和物理计算的新生javascript库
05-20
事实是，我想用JavaScript进行以前在Python / MATLAB中进行过的工程/物理计算，而且我找不到一个库，该库涵盖了很多不仅仅可以做的基础知识自己写更有意义。 JavaScript永远不会成为一种强大的计算语言，但至少要...
thonny添加库_学习用 Thonny 写代码： 一个面向初学者的Python IDE
weixin_39584405的博客
12-20 1614
学习编程很难。即使当你最终怎么正确使用你的冒号和括号，但仍然有很大的可能你的程序不会如果所想的工作。 通常，这意味着你忽略了某些东西或者误解了语言结构，你需要在代码中找到你的期望与现实存在分歧的地方。程序员通常使用被叫做 调试器 debugger 的工具来处理这种情况，它允许一步一步地运行他们的程序。不幸的是，大多数调试器都针对专业用途进行了优化，并假设用户已经很好地了解了语言结构的语义(例如：函...
数学库（math）
lianghui0811
08-13 4306
数学库由一组标准的数学函数构成，包括三角函数（sin,cos,tan,atan等）、指数和对数函数（exp、log、log10）、取整函数（floor、ceil）、max和min、生成伪随机数的函数（random、randomseed），以及变量pi和huge。其中huge为Lua中可以表示最大的数字。      1、所有的三角函数都使用弧度单位，可以用函数deg和rad来转换角度和弧度。如果使
cmath
大肉包的博客
07-11 1159
cmath是c++语言中的库函数，其中的c表示函数是来自c标准库的函数，math为数学常用库函数。 cmath库函数列表: std::pow();//求幂函数 std::exp();//指数函数 std::sqrt();//平方根 以及：log，log10；sin；cos；tan等函数。 C语言提供了以下的数学函数，要使用这些函数时，在程序文件头必须加入： #include 编译
SSE优化在数学库中的应用之四
aa649292786的博客
06-26 260
引自：http://hi.baidu.com/sige_online/blog/item/d8fdfffc8f0033f7fd037fac.html 我和这个家伙打交道已经有差不多七年时间了，所以脾性非常熟悉。首先求分量的平方和，判断是否为0（问我为什么不直接用 if( len == 0 )？好样的，请先去复习一下浮点数的基本知识），然后再求倒数，最后反映到分量上。在把它写成SSE...
SSE优化在数学库中的应用之三
aa649292786的博客
06-26 214
引自：http://hi.baidu.com/sige_online/blog/item/d8fdfffc8f0033f7fd037fac.html 然后我们把注意力放到一条非常特殊的指令shufps（对应intrinsic是_mm_shuffle_ps）上面。这是一条非常有用的指令，它可以把两个操作数的分量以特定的顺序排列并赋予给目标数。比如 __m128 b = _mm_sh...
我写了一个仿 tc graphics.h 图形库
ok2384233的博客
01-17 2116
#include int main() { int i = 0,color = 0; int gmode = DETECT; COLORREF paintcolor[3]; HideConsoleCur(); initgraph(&gmode,0,"C:\\tc");/* 进入图形模式 */ settextstyle("微软雅黑"
C++库文件 <cmath> (math.h)
热门推荐
程序员菜鸟
12-02 4万+
C++ 库函数 数学头文件 math.h
＜cmath＞库
weixin_51958878的博客
01-06 1906
ACM第一次训练—学习总结（2） C++基础知识总结 C++标准库——<cmath> 头文件：#include<cmath> 常用函数： sqrt(n)函数 //对参数n开根号 int n=121; cout<<sqrt(n)<<endl; //输出：11 cout<<sqrt(256)<<endl; //输出：16 pow(a,n)函数 //求参数a的n次方 注： pow函数的返回类型的double,使用的时候尽量试d
使用if-else编写数学库函数，绝对值和对数
m0_65054279的博客
03-02 7837
#include<stdio.h> #include<math.h> int main() { double x,y; printf("请输入x的值: "); scanf("%lf",&x); if(x<=1) y=fabs(x); else y=log(x)+1; printf("y=%.2f\n",y); return 0; } 首先还是老规矩，头文件写出来。不同的是，由于我...
用golang写一个数学公式识别系统
最新发布
04-19
如果你要用Golang编写数学公式识别系统，可以使用第三方库，例如Mathpix API或textract等，这些库可以将图像中的数学公式转化成LaTeX代码或JSON格式，方便进一步处理和分析。你可以在GitHub上找到已有的Golang实现，...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值