C#，数值计算——分数阶的贝塞尔函数（Bessel functions of fractional order）源代码

news2024/9/23 5:17:43

分数阶微积分这一重要的数学分支，其诞生在1695年，几乎和经典微积分同时出现。那一年，德国数学家Leibniz 和法国数学家L'Hopital 通信，探讨当导数的阶变为1/2时，其意义是什么？当时Leibniz也不知道定义与意义，只是回复道：“”这会导致悖论，终有一天将会是一个很有用的结果”。分数阶微积分狭义上主要包括分数阶微分与分数阶积分，广义上同时包括分数阶差分与分数阶和商。由于近一些年分数阶微积分的理论成功应用到各大领域中，人们逐渐发现分数阶微积分能够刻画自然科学以及工程应用领域一些非经典现象。分数阶微积分比较热门领域包括：分数阶数值算法，分数阶同步等问题。

using System;

namespace Legalsoft.Truffer
{
    /// <summary>
    /// Bessel functions of fractional order
    /// </summary>
    public class Bessel
    {
        private const int NUSE1 = 7;
        private const int NUSE2 = 8;
        //private double[] c1 { get; set; } = new double[7]; NUSE1];
        //private double[] c2 { get; set; } = new double[8]; NUSE2];
        private static double[] c1 = {-1.142022680371168e0,6.5165112670737e-3,
      3.087090173086e-4,-3.4706269649e-6,6.9437664e-9,3.67795e-11,
      -1.356e-13};
        private static double[] c2 = {1.843740587300905e0,-7.68528408447867e-2,
      1.2719271366546e-3,-4.9717367042e-6,-3.31261198e-8,2.423096e-10,
      -1.702e-13,-1.49e-15};
        private double xjy { get; set; }
        private double nujy { get; set; }
        private double xik { get; set; }
        private double nuik { get; set; }
        private double xai { get; set; }
        private double xsph { get; set; }
        private double jo { get; set; }
        private double yo { get; set; }
        private double jpo { get; set; }
        private double ypo { get; set; }
        private double io { get; set; }
        private double ko { get; set; }
        private double ipo { get; set; }
        private double kpo { get; set; }
        private double aio { get; set; }
        private double bio { get; set; }
        private double aipo { get; set; }
        private double bipo { get; set; }
        private double sphjo { get; set; }
        private double sphyo { get; set; }
        private double sphjpo { get; set; }
        private double sphypo { get; set; }
        private int sphno { get; set; }

        public Bessel()
        {
            this.xjy = 9.99e99;
            this.nujy = 9.99e99;
            this.xik = 9.99e99;
            this.nuik = 9.99e99;
            this.xai = 9.99e99;
            this.sphno = -9999;
        }

        public double jnu(double nu, double x)
        {
            if (nu != nujy || x != xjy)
            {
                besseljy(nu, x);
            }
            return jo;
        }

        public double ynu(double nu, double x)
        {
            if (nu != nujy || x != xjy)
            {
                besseljy(nu, x);
            }
            return yo;
        }

        public double inu(double nu, double x)
        {
            if (nu != nuik || x != xik)
            {
                besselik(nu, x);
            }
            return io;
        }

        public double knu(double nu, double x)
        {
            if (nu != nuik || x != xik)
            {
                besselik(nu, x);
            }
            return ko;
        }


        public double chebev(double[] c, int m, double x)
        {
            double d = 0.0;
            double dd = 0.0;
            double sv;
            int j;
            for (j = m - 1; j > 0; j--)
            {
                sv = d;
                d = 2.0 * x * d - dd + c[j];
                dd = sv;
            }
            return x * d - dd + 0.5 * c[0];
        }

        public void besseljy(double nu, double x)
        {
            const int MAXIT = 10000;
            const double EPS = float.Epsilon;
            const double FPMIN = float.MinValue;//  float.MinValue / EPS;
            const double XMIN = 2.0;

            if (x <= 0.0 || nu < 0.0)
            {
                throw new Exception("bad arguments in besseljy");
            }
            int nl = (x < XMIN ? (int)(nu + 0.5) : Math.Max(0, (int)(nu - x + 1.5)));
            double xmu = nu - nl;
            double xmu2 = xmu * xmu;
            double xi = 1.0 / x;
            double xi2 = 2.0 * xi;
            double w = xi2 / Math.PI;
            int isign = 1;
            double h = nu * xi;
            if (h < FPMIN)
            {
                h = FPMIN;
            }
            double b = xi2 * nu;
            double d = 0.0;
            double c = h;
            int i = 0;
            for (; i < MAXIT; i++)
            {
                b += xi2;
                d = b - d;
                if (Math.Abs(d) < FPMIN)
                {
                    d = FPMIN;
                }
                c = b - 1.0 / c;
                if (Math.Abs(c) < FPMIN)
                {
                    c = FPMIN;
                }
                d = 1.0 / d;
                double del = c * d;
                h = del * h;
                if (d < 0.0)
                {
                    isign = -isign;
                }
                if (Math.Abs(del - 1.0) <= EPS)
                {
                    break;
                }
            }
            if (i >= MAXIT)
            {
                throw new Exception("x too large in besseljy; try asymptotic expansion");
            }
            double rjl = isign * FPMIN;
            double rjpl = h * rjl;
            double rjl1 = rjl;
            double rjp1 = rjpl;
            double fact = nu * xi;
            for (int l = nl - 1; l >= 0; l--)
            {
                double rjtemp = fact * rjl + rjpl;
                fact -= xi;
                rjpl = fact * rjtemp - rjl;
                rjl = rjtemp;
            }
            //if (rjl == 0.0)
            if (Math.Abs(rjl) <= float.Epsilon)
            {
                rjl = EPS;
            }

            double f = rjpl / rjl;
            double rjmu;
            double rytemp;
            double ry1;
            double rymu;
            if (x < XMIN)
            {
                double x2 = 0.5 * x;
                double pimu = Math.PI * xmu;
                fact = (Math.Abs(pimu) < EPS ? 1.0 : pimu / Math.Sin(pimu));
                d = -Math.Log(x2);
                double e = xmu * d;
                double fact2 = (Math.Abs(e) < EPS ? 1.0 : Math.Sinh(e) / e);
                double xx = 8.0 * Globals.SQR(xmu) - 1.0;
                double gam1 = chebev(c1, NUSE1, xx);
                double gam2 = chebev(c2, NUSE2, xx);
                double gampl = gam2 - xmu * gam1;
                double gammi = gam2 + xmu * gam1;
                double ff = 2.0 / Math.PI * fact * (gam1 * Math.Cosh(e) + gam2 * fact2 * d);
                e = Math.Exp(e);
                double p = e / (gampl * Math.PI);
                double q = 1.0 / (e * Math.PI * gammi);
                double pimu2 = 0.5 * pimu;
                double fact3 = (Math.Abs(pimu2) < EPS ? 1.0 : Math.Sin(pimu2) / pimu2);
                double r = Math.PI * pimu2 * fact3 * fact3;
                c = 1.0;
                d = -x2 * x2;
                double sum = ff + r * q;
                double sum1 = p;
                for (i = 1; i <= MAXIT; i++)
                {
                    ff = (i * ff + p + q) / (i * i - xmu2);
                    c *= (d / i);
                    p /= (i - xmu);
                    q /= (i + xmu);
                    double del = c * (ff + r * q);
                    sum += del;
                    double del1 = c * p - i * del;
                    sum1 += del1;
                    if (Math.Abs(del) < (1.0 + Math.Abs(sum)) * EPS)
                    {
                        break;
                    }
                }
                if (i > MAXIT)
                {
                    throw new Exception("bessy series failed to converge");
                }
                rymu = -sum;
                ry1 = -sum1 * xi2;
                double rymup = xmu * xi * rymu - ry1;
                rjmu = w / (rymup - f * rymu);
            }
            else
            {
                double a = 0.25 - xmu2;
                double p = -0.5 * xi;
                double q = 1.0;
                double br = 2.0 * x;
                double bi = 2.0;
                fact = a * xi / (p * p + q * q);
                double cr = br + q * fact;
                double ci = bi + p * fact;
                double den = br * br + bi * bi;
                double dr = br / den;
                double di = -bi / den;
                double dlr = cr * dr - ci * di;
                double dli = cr * di + ci * dr;
                double temp = p * dlr - q * dli;
                q = p * dli + q * dlr;
                p = temp;
                for (i = 1; i < MAXIT; i++)
                {
                    a += 2 * i;
                    bi += 2.0;
                    dr = a * dr + br;
                    di = a * di + bi;
                    if (Math.Abs(dr) + Math.Abs(di) < FPMIN)
                    {
                        dr = FPMIN;
                    }
                    fact = a / (cr * cr + ci * ci);
                    cr = br + cr * fact;
                    ci = bi - ci * fact;
                    if (Math.Abs(cr) + Math.Abs(ci) < FPMIN)
                    {
                        cr = FPMIN;
                    }
                    den = dr * dr + di * di;
                    dr /= den;
                    di /= -den;
                    dlr = cr * dr - ci * di;
                    dli = cr * di + ci * dr;
                    temp = p * dlr - q * dli;
                    q = p * dli + q * dlr;
                    p = temp;
                    if (Math.Abs(dlr - 1.0) + Math.Abs(dli) <= EPS)
                    {
                        break;
                    }
                }
                if (i >= MAXIT)
                {
                    throw new Exception("cf2 failed in besseljy");
                }
                double gam = (p - f) / q;
                rjmu = Math.Sqrt(w / ((p - f) * gam + q));
                rjmu = Globals.SIGN(rjmu, rjl);
                rymu = rjmu * gam;
                double rymup = rymu * (p + q / gam);
                ry1 = xmu * xi * rymu - rymup;
            }
            fact = rjmu / rjl;
            jo = rjl1 * fact;
            jpo = rjp1 * fact;
            for (i = 1; i <= nl; i++)
            {
                rytemp = (xmu + i) * xi2 * ry1 - rymu;
                rymu = ry1;
                ry1 = rytemp;
            }
            yo = rymu;
            ypo = nu * xi * rymu - ry1;
            xjy = x;
            nujy = nu;
        }

        public void besselik(double nu, double x)
        {
            const int MAXIT = 10000;
            const double EPS = float.Epsilon;
            const double FPMIN = float.MinValue;//  float.MinValue / EPS;
            const double XMIN = 2.0;

            if (x <= 0.0 || nu < 0.0)
            {
                throw new Exception("bad arguments in besselik");
            }
            int nl = (int)(nu + 0.5);
            double xmu = nu - nl;
            double xmu2 = xmu * xmu;
            double xi = 1.0 / x;
            double xi2 = 2.0 * xi;
            double h = nu * xi;
            if (h < FPMIN)
            {
                h = FPMIN;
            }
            double b = xi2 * nu;
            double d = 0.0;
            double c = h;
            int i = 0;
            for (; i < MAXIT; i++)
            {
                b += xi2;
                d = 1.0 / (b + d);
                c = b + 1.0 / c;
                double del = c * d;
                h = del * h;
                if (Math.Abs(del - 1.0) <= EPS)
                {
                    break;
                }
            }
            if (i >= MAXIT)
            {
                throw new Exception("x too large in besselik; try asymptotic expansion");
            }
            double ril = FPMIN;
            double ripl = h * ril;
            double ril1 = ril;
            double rip1 = ripl;
            double fact = nu * xi;
            for (int l = nl - 1; l >= 0; l--)
            {
                double ritemp = fact * ril + ripl;
                fact -= xi;
                ripl = fact * ritemp + ril;
                ril = ritemp;
            }

            double f = ripl / ril;
            double rk1;
            double rkmu;
            if (x < XMIN)
            {
                double x2 = 0.5 * x;
                double pimu = Math.PI * xmu;
                fact = (Math.Abs(pimu) < EPS ? 1.0 : pimu / Math.Sin(pimu));
                d = -Math.Log(x2);
                double e = xmu * d;
                double fact2 = (Math.Abs(e) < EPS ? 1.0 : Math.Sinh(e) / e);
                double xx = 8.0 * Globals.SQR(xmu) - 1.0;
                double gam1 = chebev(c1, NUSE1, xx);
                double gam2 = chebev(c2, NUSE2, xx);
                double gampl = gam2 - xmu * gam1;
                double gammi = gam2 + xmu * gam1;
                double ff = fact * (gam1 * Math.Cosh(e) + gam2 * fact2 * d);
                double sum = ff;
                e = Math.Exp(e);
                double p = 0.5 * e / gampl;
                double q = 0.5 / (e * gammi);
                c = 1.0;
                d = x2 * x2;
                double sum1 = p;
                for (i = 1; i <= MAXIT; i++)
                {
                    ff = (i * ff + p + q) / (i * i - xmu2);
                    c *= (d / i);
                    p /= (i - xmu);
                    q /= (i + xmu);
                    double del = c * ff;
                    sum += del;
                    double del1 = c * (p - i * ff);
                    sum1 += del1;
                    if (Math.Abs(del) < Math.Abs(sum) * EPS)
                    {
                        break;
                    }
                }
                if (i > MAXIT)
                {
                    throw new Exception("bessk series failed to converge");
                }
                rkmu = sum;
                rk1 = sum1 * xi2;
            }
            else
            {
                b = 2.0 * (1.0 + x);
                d = 1.0 / b;
                h = d;
                double delh = d;
                double q1 = 0.0;
                double q2 = 1.0;
                double a1 = 0.25 - xmu2;
                double q = c = a1;
                double a = -a1;
                double s = 1.0 + q * delh;
                for (i = 1; i < MAXIT; i++)
                {
                    a -= 2 * i;
                    c = -a * c / (i + 1.0);
                    double qnew = (q1 - b * q2) / a;
                    q1 = q2;
                    q2 = qnew;
                    q += c * qnew;
                    b += 2.0;
                    d = 1.0 / (b + a * d);
                    delh = (b * d - 1.0) * delh;
                    h += delh;
                    double dels = q * delh;
                    s += dels;
                    if (Math.Abs(dels / s) <= EPS)
                    {
                        break;
                    }
                }
                if (i >= MAXIT)
                {
                    throw new Exception("besselik: failure to converge in cf2");
                }
                h = a1 * h;
                rkmu = Math.Sqrt(Math.PI / (2.0 * x)) * Math.Exp(-x) / s;
                rk1 = rkmu * (xmu + x + 0.5 - h) * xi;
            }
            double rkmup = xmu * xi * rkmu - rk1;
            double rimu = xi / (f * rkmu - rkmup);
            io = (rimu * ril1) / ril;
            ipo = (rimu * rip1) / ril;
            for (i = 1; i <= nl; i++)
            {
                double rktemp = (xmu + i) * xi2 * rk1 + rkmu;
                rkmu = rk1;
                rk1 = rktemp;
            }
            ko = rkmu;
            kpo = nu * xi * rkmu - rk1;
            xik = x;
            nuik = nu;
        }

        public void airy(double x)
        {
            const double ONOVRT = 0.577350269189626;
            const double THR = 1.0 / 3.0;
            const double TWOTHR = 2.0 * THR;

            double absx = Math.Abs(x);
            double rootx = Math.Sqrt(absx);
            double z = TWOTHR * absx * rootx;
            if (x > 0.0)
            {
                besselik(THR, z);
                aio = rootx * ONOVRT * ko / Math.PI;
                bio = rootx * (ko / Math.PI + 2.0 * ONOVRT * io);
                besselik(TWOTHR, z);
                aipo = -x * ONOVRT * ko / Math.PI;
                bipo = x * (ko / Math.PI + 2.0 * ONOVRT * io);
            }
            else if (x < 0.0)
            {
                besseljy(THR, z);
                aio = 0.5 * rootx * (jo - ONOVRT * yo);
                bio = -0.5 * rootx * (yo + ONOVRT * jo);
                besseljy(TWOTHR, z);
                aipo = 0.5 * absx * (ONOVRT * yo + jo);
                bipo = 0.5 * absx * (ONOVRT * jo - yo);
            }
            else
            {
                aio = 0.355028053887817;
                bio = aio / ONOVRT;
                aipo = -0.258819403792807;
                bipo = -aipo / ONOVRT;
            }
        }

        public double airy_ai(double x)
        {
            if (x != xai)
            {
                airy(x);
            }
            return aio;
        }

        public double airy_bi(double x)
        {
            if (x != xai)
            {
                airy(x);
            }
            return bio;
        }

        public void sphbes(int n, double x)
        {
            const double RTPIO2 = 1.253314137315500251;

            if (n < 0 || x <= 0.0)
            {
                throw new Exception("bad arguments in sphbes");
            }
            double order = n + 0.5;
            besseljy(order, x);
            double factor = RTPIO2 / Math.Sqrt(x);
            sphjo = factor * jo;
            sphyo = factor * yo;
            sphjpo = factor * jpo - sphjo / (2.0 * x);
            sphypo = factor * ypo - sphyo / (2.0 * x);
            sphno = n;
        }

        public double sphbesj(int n, double x)
        {
            if (n != sphno || x != xsph)
            {
                sphbes(n, x);
            }
            return sphjo;
        }

        public double sphbesy(int n, double x)
        {
            if (n != sphno || x != xsph)
            {
                sphbes(n, x);
            }
            return sphyo;
        }
    }
}
 

本文来自互联网用户投稿，该文观点仅代表作者本人，不代表本站立场。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如若转载，请注明出处：http://www.coloradmin.cn/o/735619.html

如若内容造成侵权/违法违规/事实不符，请联系多彩编程网进行投诉反馈，一经查实，立即删除！

相关文章

强化学习-理解及应用:解决迷宫问题

强化学习-理解及应用:解决迷宫问题

什么是强化学习&#xff1f; 强化学习&#xff08;Reinforcement Learning, RL&#xff09;是一种机器学习方法&#xff0c;旨在让智能体&#xff08;agent&#xff09;通过与环境的交互学习如何做出最优的行动选择以获得最大的累积奖励。 7个基本概念 强化学习主要由智能体…
阅读更多...
YApi-高效、易用、功能强大的可视化接口管理平台——（三）YApi 项目管理

YApi-高效、易用、功能强大的可视化接口管理平台——（三）YApi 项目管理

YApi 项目管理 新建项目修改项目图标项目迁移项目拷贝删除项目配置环境请求配置请求参数示例返回数据示例storage工具函数异步处理&#xff08;v1.3.13支持&#xff09; token全局mock 新建项目 点击右上角的 新建项目&#xff0c;进入新建项目页面&#xff1a; 完善项目信息…
阅读更多...
JVM理论（三）运行时数据区--PC寄存器／虚拟机栈／本地方法栈

JVM理论（三）运行时数据区--PC寄存器／虚拟机栈／本地方法栈

运行时数据区(JVM内存结构) JVM内存结构 内存是非常重要的资源,是硬盘和CPU的中间桥梁,承载操作系统和应用程序的实时运行.JVM内存布局规定java在运行过程中内存申请、分配、管理的策略&#xff0c;保证JVM高效稳定运行。不同的JVM对于内存划分和管理机制存在部分差异(如J9和JR…
阅读更多...
Nacos2.3.0源码启动报错找不到符号com.alibaba.nacos.consistency.entity

Nacos2.3.0源码启动报错找不到符号com.alibaba.nacos.consistency.entity

一. 源码下载编译&#xff1a;找不到符号com.alibaba.nacos.consistency.entity 如果报错找不到符号com.alibaba.nacos.consistency.entity Nacos\consistency\src\main\java\com\alibaba\nacos\consistency\entity 这个包下没有相关的java文件&#xff0c;其实是我们没有编译…
阅读更多...
Vue.js 双向数据绑定的具体实现代码（简洁版）

Vue.js 双向数据绑定的具体实现代码（简洁版）

1、 执行初始化&#xff0c;对data执行响应化处理 先来一个构造函数&#xff1a;执行初始化&#xff0c;对data执行响应化处理 class Vue { constructor(options) { this.$options options; this.$data options.data; // 对data选项做响应式处理 observe(this.$data);…
阅读更多...
Linux性能优化实践——CPU上下文

Linux性能优化实践——CPU上下文

CPU上下文切换 Linux是一个多任务操作系统&#xff0c;它支持远大于CPU数量的任务同时运行。这些任务不是真正意义上的并行运行&#xff0c;而是系统在短时间内&#xff0c;将CPU轮流分配给它们&#xff0c;造成任务同时运行的错觉。 CPU需要知道任务从哪里加载&#xff0c;从…
阅读更多...
使用 OpenVINO™ 转换和优化 YOLOv8

使用 OpenVINO™ 转换和优化 YOLOv8

本教程还可以作为 Jupyter Notebook 提供，可以直接从 GitHub 克隆。请参阅安装指南，了解在 Windows、Linux 或 macOS 上本地运行本教程的说明。 Ultralytics 开发的 YOLOv8 算法是一种尖端、最先进的 (SOTA) 模型，旨在快速、准确且易于使用，使其成为各种物体检测、图像分割…
阅读更多...
Cartoon头像 InsCode Stable Diffusion 美图活动一期

Cartoon头像 InsCode Stable Diffusion 美图活动一期

一. 简单介绍和活动地址 简单介绍 试用Stable Diffusion 模型生成优质人物好图&#xff0c;更简单地炼丹。 “InsCode是一个集成了在线IDE、在线AI编程、在线算力租赁、在线项目部署以及在线SD 模型使用的综合代码开发平台。不论你是初级软件工程师&#xff0c;还是AI大模型…
阅读更多...
【Java】删除集合元素的正确与错误做法

【Java】删除集合元素的正确与错误做法

错误做法 一、fori正序 list.remove(num) Test public void test031(){ ArrayList<Integer> list new ArrayList<>(); list.add(1); list.add(3); list.add(3); for (int i 0; i < list.size(); i) { Integer numlist.get(i); if(num3){ list.re…
阅读更多...
数据集 VOC转YOLO格式

数据集 VOC转YOLO格式

一、xml转换为txt import os.path import xml.etree.ElementTree as ET import os import random # class_names [palm, stone, scissor, awesome, heartB, OK, ROCK, one, swear, thanks, heartA, # heartC, good, bad, pray, call, take_picture, salute] c…
阅读更多...
Java：缓冲流

Java：缓冲流

1.缓冲流分类 2.字节缓冲流 原理:底层自带了长度为8192的缓冲区提高性能。 1.方法&#xff1a; public BufferedInputstream( Inputstream is)&#xff1a;把基本流包装成高级流&#xff0c;提高读取数据的性能。public BufferedOutputStream(OutputStream os)把基本流包装成…
阅读更多...
【Java|基础篇】面向对象三大特性之继承(上)

【Java|基础篇】面向对象三大特性之继承(上)

文章目录 1. 前言2. 问题提出3. 什么是继承4. 继承的特点 1. 前言 继承是面向对象三大特性之一. Java的继承也是很复杂. 本篇文章先帮助大家理解继承的概念 2. 问题提出 先来看这两个类: Student类: public class Student {private String name;private int age;private S…
阅读更多...
【技能实训】DMS数据挖掘项目-Day02

【技能实训】DMS数据挖掘项目-Day02

文章目录 任务3【任务3.1】实现日志实体类【任务3.2】创建日志业务类&#xff0c;实现日志信息的采集及打印输出【任务3.3】创建日志测试类&#xff0c;测试任务3.2中的程序&#xff0c;演示日志信息的采集及打印输出 任务4【任务4.1】物流实体信息类【任务4.2】创建物流业务类…
阅读更多...
Slicer学习笔记（六十四） 关于3DSlicer的python脚本和编程

Slicer学习笔记（六十四） 关于3DSlicer的python脚本和编程

Slicer学习笔记（六十四） 关于3DSlicer的python脚本和编程 目标1. 软件结构2. 在Slicer中使用python控制台 简单的脚本模块示例3. 单独编写简单的脚本模块目标 1. 软件结构 Slicer应用程序架构 模块类型:c++可加载 模块类型:脚本加载 模块类型:CLI Slicer数据模型 MRML
阅读更多...
SendGrid 无法注册，Create Account 按钮灰色无法点击

SendGrid 无法注册，Create Account 按钮灰色无法点击

问题描述&#xff1a; 注册SendGrid的时候&#xff0c;账号密码都输好了&#xff0c;就是没办法点【Create Account】。 解释思路&#xff1a; 其实空白处有一个reCAPTCHA 验证码&#xff0c;但是被隐去了。所以我们的思路是如何让网页中的reCAPTCHA 验证码顺利显示出来。 问…
阅读更多...
vue实现一个购物车全功能

vue实现一个购物车全功能

效果图: 1.静态代码结构渲染 <div class"app-container" id"app"><!-- 顶部banner --><div class"banner-box"><img src"http://autumnfish.cn/static/fruit.jpg" alt"" /></div><!-- 面包…
阅读更多...
了解个人所得税

了解个人所得税

文章目录 1 个人所得税1.1 前置知识&#xff08;一定多看几遍&#xff09;1.2 个人所得税计算 2 汇算清缴参考 1 个人所得税 1.1 前置知识&#xff08;一定多看几遍&#xff09; 首先我们要弄清楚几个概念&#xff1a; ① 应纳税所得额 综合所得额 - 免征 - 扣除 ② 综合所…
阅读更多...
Selenium浏览器自动化测试框架简单介绍

Selenium浏览器自动化测试框架简单介绍

目录 selenium简介 介绍 功能 优势 基本使用 获取单节点 获取多节点 节点交互 动作链 执行JavaScript代码 获取节点信息 切换frame 延时等待 前进和后退 cookies 选项卡管理 异常处理 选项卡切换 无头浏览器 selenium简介 介绍 Selenium [1] 是一个用于We…
阅读更多...
VectorCAST软件的License 配置

VectorCAST软件的License 配置

一、配置 License 服务 进入 VectorCAST 安装目录&#xff08;默认为 C:\VCAST&#xff0c;如果在安装时修改了安装路径&#xff0c;在这里需要进入对 应的安装目录&#xff09;&#xff0c;找到 FLEXlm 文件夹&#xff0c;将 License 文件复制到 FLEXlm 文件夹下面。运行 lmt…
阅读更多...
当你按下键盘A键

当你按下键盘A键

CPU 里面的内存接口&#xff0c;直接和系统总线通信&#xff0c;然后系统总线再接入一个 I/O 桥接器&#xff0c;这个 I/O 桥接器&#xff0c;另一边接入了内存总线&#xff0c;使得 CPU 和内存通信。再另一边&#xff0c;又接入了一个 I/O 总线&#xff0c;用来连接 I/O 设备&…
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023