C#，《小白学程序》第二十七课：大数四则运算之“运算符重载”的算法及源程序

1 文本格式

using System;
using System.Text;
using System.Collections;
using System.Collections.Generic;

/// <summary>
/// 大数的四则（加减乘除）运算
/// 及其运算符重载（取余数）
/// </summary>
public class BigNumber
{
    private string Buffer { get; set; } = "";
    private string Sign { get; set; } = "";
    public BigNumber(int n) { Next(n); }
    public BigNumber(string b, string s = "")
    {
        Buffer = b;
        Sign = s;
    }
    public BigNumber Clone()
    {
        BigNumber r = new BigNumber(Buffer, Sign);
        return r;
    }
    public int Length { get { return Buffer.Length; } }

    /// <summary>
    /// 随机生成任意长度的大数（BigNumber）
    /// </summary>
    /// <param name="n">位数</param>
    /// <returns></returns>
    public void Next(int n)
    {
        Random rnd = new Random();
        StringBuilder sb = new StringBuilder();
        sb.Append((rnd.Next(9) + 1).ToString());
        for (int i = 1; i < n; i++)
        {
            sb.Append((rnd.Next(10)).ToString());
        }
        Buffer = sb.ToString();
    }

    /// <summary>
    /// 字符串型的数字转为数组(低位（右）在前)
    /// </summary>
    /// <param name="a"></param>
    /// <param name="n">最大位数，后面留0</param>
    /// <returns></returns>
    public static int[] string_to_digitals(string a, int n)
    {
        char[] c = a.ToCharArray();
        int[] d = new int[n];
        for (int i = a.Length - 1, j = 0; i >= 0; i--)
        {
            if (c[i] == '-') continue;
            d[j++] = c[i] - '0';
        }
        return d;
    }

    /// <summary>
    /// 数组型数字转为字符串型(低位（右）在前)
    /// </summary>
    /// <param name="d"></param>
    /// <returns></returns>
    public static string digitals_to_string(int[] d)
    {
        int n = d.Length;
        int k = n - 1;
        while ((k >= 0) && (d[k] == 0)) k--;
        if (k >= 0)
        {
            StringBuilder sb = new StringBuilder();
            for (; k >= 0; k--) sb.Append(d[k]);
            return sb.ToString();
        }
        else
        {
            return "0";
        }
    }

    /// <summary>
    /// 大数加法 c = a + b
    /// </summary>
    /// <param name="a"></param>
    /// <param name="b"></param>
    /// <returns></returns>
    public static string big_integer_plus(string a, string b)
    {
        int n = Math.Max(a.Length, b.Length) + 1;
        // 位数不长的数字直接计算
        if (n <= 18)
        {
            return (ulong.Parse(a) + ulong.Parse(b)).ToString();
        }

        int[] da = string_to_digitals(a, n);
        int[] db = string_to_digitals(b, n);

        int[] dc = new int[n];
        Array.Copy(da, dc, n);
        for (int i = 0; i < (n - 1); i++)
        {
            dc[i] = dc[i] + db[i];
            if (dc[i] > 9)
            {
                dc[i] -= 10;
                dc[i + 1] += 1;
            }
        }
        return digitals_to_string(dc);
    }

    /// <summary>
    /// 大数减法 c = a - b
    /// </summary>
    /// <param name="a"></param>
    /// <param name="b"></param>
    /// <returns></returns>
    public static string big_integer_subtract(string a, string b)
    {
        int na = a.Length;
        int nb = b.Length;
        int n = Math.Max(na, nb) + 1;
        if (n <= 18)
        {
            return (ulong.Parse(a) - ulong.Parse(b)).ToString();
        }
        int[] da = string_to_digitals(a, n);
        int[] db = string_to_digitals(b, n);

        for (int i = 0; i < na; i++)
        {
            da[i] -= db[i];
            if (da[i] < 0)
            {
                da[i] += 10;
                da[i + 1] -= 1;
            }
        }
        return digitals_to_string(da);
    }

    /// <summary>
    /// 大数乘法 c = a * b
    /// </summary>
    /// <param name="a"></param>
    /// <param name="b"></param>
    /// <returns></returns>
    public static string big_integer_multiply(string a, string b)
    {
        int na = a.Length;
        int nb = b.Length;
        int n = na + nb + 1;
        int[] da = string_to_digitals(a, n);
        int[] db = string_to_digitals(b, n);

        int[] dc = new int[n];
        for (int i = 0; i < na; i++)
        {
            for (int j = 0; j < nb; j++)
            {
                dc[i + j] += da[i] * db[j];
            }
        }
        for (int i = 0; i < n; i++)
        {
            if (dc[i] >= 10)
            {
                dc[i + 1] += (dc[i] / 10);
                dc[i] %= 10;
            }
        }

        return digitals_to_string(dc);
    }

    /// <summary>
    /// 比较a，b的大小，返回1，0，-1
    /// 数据从低位（右）往高位（左）存储;
    /// </summary>
    /// <param name="a"></param>
    /// <param name="b"></param>
    /// <returns></returns>
    public static int big_integer_compare(int[] a, int[] b)
    {
        for (int i = a.Length - 1; i >= 0; i--)
        {
            if (a[i] > b[i]) return 1;
            else if (a[i] < b[i]) return -1;
        }
        return 0;
    }

    public static int big_integer_compare(string a, string b)
    {
        int n = Math.Max(a.Length, b.Length);
        int[] da = string_to_digitals(a, n);
        int[] db = string_to_digitals(a, n);
        return big_integer_compare(da, db);
    }

    /// <summary>
    /// 大数除法 c = a / b % d
    /// c 为商，d 为余数。
    /// </summary>
    /// <param name="a"></param>
    /// <param name="b"></param>
    /// <param name="d">余数</param>
    /// <returns>商c</returns>
    public static string big_integer_divide(string a, string b, out string d)
    {
        int n = a.Length;
        int[] db = string_to_digitals(b, n);

        string q = a;
        List<string> p = new List<string>();
        int[] dq = string_to_digitals(q, n);
        while (big_integer_compare(dq, db) >= 0)
        {
            int len = q.Length - b.Length;
            string v2 = b + String.Join("", new int[len]);
            int[] dv = string_to_digitals(v2, n);
            if (big_integer_compare(dq, dv) < 0)
            {
                len--;
                v2 = b + String.Join("", new int[len]);
                dv = string_to_digitals(v2, n);
            }

            string v1 = "1" + String.Join("", new int[len]);
            while (big_integer_compare(dq, dv) >= 0)
            {
                p.Add(v1);
                q = big_integer_subtract(q, v2);
                dq = string_to_digitals(q, n);
            }
        }

        d = q;

        string r = p[0];
        for (int i = 1; i < p.Count; i++)
        {
            r = big_integer_plus(r, p[i]);
        }
        return r;
    }

    #region 四则运算符（含取余数）重载

    // 运算符重载是一种常用的编程技术。
    // 用于支持“非数值类型的数据（比如类）”以常用的运算符 +-*/% 等等进行运算，使得代码简约直观。
    // 没有运算符重载的语言（比如golang）一般都不适合数值计算。

    public static BigNumber operator +(BigNumber a, BigNumber b)
    {
        return new BigNumber(big_integer_plus(a.Buffer, b.Buffer));
    }
    public static BigNumber operator -(BigNumber a, BigNumber b)
    {
        if (a > b || a == b)
            return new BigNumber(big_integer_subtract(a.Buffer, b.Buffer));
        else
            return new BigNumber(big_integer_subtract(b.Buffer, a.Buffer), "-");
    }
    public static BigNumber operator *(BigNumber a, BigNumber b)
    {
        return new BigNumber(big_integer_multiply(a.Buffer, b.Buffer));
    }
    public static BigNumber operator /(BigNumber a, BigNumber b)
    {
        return new BigNumber(big_integer_divide(a.Buffer, b.Buffer, out string _));
    }
    public static BigNumber operator %(BigNumber a, BigNumber b)
    {
        string c = big_integer_divide(a.Buffer, b.Buffer, out string d);
        return new BigNumber(d);
    }
    public static bool operator >(BigNumber a, BigNumber b)
    {
        return big_integer_compare(a.Buffer, b.Buffer) > 0;
    }
    public static bool operator <(BigNumber a, BigNumber b)
    {
        return big_integer_compare(a.Buffer, b.Buffer) < 0;
    }
    public static bool operator ==(BigNumber a, BigNumber b)
    {
        return big_integer_compare(a.Buffer, b.Buffer) == 0;
    }
    public static bool operator !=(BigNumber a, BigNumber b)
    {
        return big_integer_compare(a.Buffer, b.Buffer) != 0;
    }
    public static bool Equals(BigNumber a, BigNumber b) { return (a == b); }

    public override string ToString()
    {
        return Sign + Buffer;
    }
    #endregion
}
 

2 代码格式

using System;
using System.Text;
using System.Collections;
using System.Collections.Generic;

/// <summary>
/// 大数的四则（加减乘除）运算
/// 及其运算符重载（取余数）
/// </summary>
public class BigNumber
{
    private string Buffer { get; set; } = "";
    private string Sign { get; set; } = "";
    public BigNumber(int n) { Next(n); }
    public BigNumber(string b, string s = "")
    {
        Buffer = b;
        Sign = s;
    }
    public BigNumber Clone()
    {
        BigNumber r = new BigNumber(Buffer, Sign);
        return r;
    }
    public int Length { get { return Buffer.Length; } }

    /// <summary>
    /// 随机生成任意长度的大数（BigNumber）
    /// </summary>
    /// <param name="n">位数</param>
    /// <returns></returns>
    public void Next(int n)
    {
        Random rnd = new Random();
        StringBuilder sb = new StringBuilder();
        sb.Append((rnd.Next(9) + 1).ToString());
        for (int i = 1; i < n; i++)
        {
            sb.Append((rnd.Next(10)).ToString());
        }
        Buffer = sb.ToString();
    }

    /// <summary>
    /// 字符串型的数字转为数组(低位（右）在前)
    /// </summary>
    /// <param name="a"></param>
    /// <param name="n">最大位数，后面留0</param>
    /// <returns></returns>
    public static int[] string_to_digitals(string a, int n)
    {
        char[] c = a.ToCharArray();
        int[] d = new int[n];
        for (int i = a.Length - 1, j = 0; i >= 0; i--)
        {
            if (c[i] == '-') continue;
            d[j++] = c[i] - '0';
        }
        return d;
    }

    /// <summary>
    /// 数组型数字转为字符串型(低位（右）在前)
    /// </summary>
    /// <param name="d"></param>
    /// <returns></returns>
    public static string digitals_to_string(int[] d)
    {
        int n = d.Length;
        int k = n - 1;
        while ((k >= 0) && (d[k] == 0)) k--;
        if (k >= 0)
        {
            StringBuilder sb = new StringBuilder();
            for (; k >= 0; k--) sb.Append(d[k]);
            return sb.ToString();
        }
        else
        {
            return "0";
        }
    }

    /// <summary>
    /// 大数加法 c = a + b
    /// </summary>
    /// <param name="a"></param>
    /// <param name="b"></param>
    /// <returns></returns>
    public static string big_integer_plus(string a, string b)
    {
        int n = Math.Max(a.Length, b.Length) + 1;
        // 位数不长的数字直接计算
        if (n <= 18)
        {
            return (ulong.Parse(a) + ulong.Parse(b)).ToString();
        }

        int[] da = string_to_digitals(a, n);
        int[] db = string_to_digitals(b, n);

        int[] dc = new int[n];
        Array.Copy(da, dc, n);
        for (int i = 0; i < (n - 1); i++)
        {
            dc[i] = dc[i] + db[i];
            if (dc[i] > 9)
            {
                dc[i] -= 10;
                dc[i + 1] += 1;
            }
        }
        return digitals_to_string(dc);
    }

    /// <summary>
    /// 大数减法 c = a - b
    /// </summary>
    /// <param name="a"></param>
    /// <param name="b"></param>
    /// <returns></returns>
    public static string big_integer_subtract(string a, string b)
    {
        int na = a.Length;
        int nb = b.Length;
        int n = Math.Max(na, nb) + 1;
        if (n <= 18)
        {
            return (ulong.Parse(a) - ulong.Parse(b)).ToString();
        }
        int[] da = string_to_digitals(a, n);
        int[] db = string_to_digitals(b, n);

        for (int i = 0; i < na; i++)
        {
            da[i] -= db[i];
            if (da[i] < 0)
            {
                da[i] += 10;
                da[i + 1] -= 1;
            }
        }
        return digitals_to_string(da);
    }

    /// <summary>
    /// 大数乘法 c = a * b
    /// </summary>
    /// <param name="a"></param>
    /// <param name="b"></param>
    /// <returns></returns>
    public static string big_integer_multiply(string a, string b)
    {
        int na = a.Length;
        int nb = b.Length;
        int n = na + nb + 1;
        int[] da = string_to_digitals(a, n);
        int[] db = string_to_digitals(b, n);

        int[] dc = new int[n];
        for (int i = 0; i < na; i++)
        {
            for (int j = 0; j < nb; j++)
            {
                dc[i + j] += da[i] * db[j];
            }
        }
        for (int i = 0; i < n; i++)
        {
            if (dc[i] >= 10)
            {
                dc[i + 1] += (dc[i] / 10);
                dc[i] %= 10;
            }
        }

        return digitals_to_string(dc);
    }

    /// <summary>
    /// 比较a，b的大小，返回1，0，-1
    /// 数据从低位（右）往高位（左）存储;
    /// </summary>
    /// <param name="a"></param>
    /// <param name="b"></param>
    /// <returns></returns>
    public static int big_integer_compare(int[] a, int[] b)
    {
        for (int i = a.Length - 1; i >= 0; i--)
        {
            if (a[i] > b[i]) return 1;
            else if (a[i] < b[i]) return -1;
        }
        return 0;
    }

    public static int big_integer_compare(string a, string b)
    {
        int n = Math.Max(a.Length, b.Length);
        int[] da = string_to_digitals(a, n);
        int[] db = string_to_digitals(a, n);
        return big_integer_compare(da, db);
    }

    /// <summary>
    /// 大数除法 c = a / b % d
    /// c 为商，d 为余数。
    /// </summary>
    /// <param name="a"></param>
    /// <param name="b"></param>
    /// <param name="d">余数</param>
    /// <returns>商c</returns>
    public static string big_integer_divide(string a, string b, out string d)
    {
        int n = a.Length;
        int[] db = string_to_digitals(b, n);

        string q = a;
        List<string> p = new List<string>();
        int[] dq = string_to_digitals(q, n);
        while (big_integer_compare(dq, db) >= 0)
        {
            int len = q.Length - b.Length;
            string v2 = b + String.Join("", new int[len]);
            int[] dv = string_to_digitals(v2, n);
            if (big_integer_compare(dq, dv) < 0)
            {
                len--;
                v2 = b + String.Join("", new int[len]);
                dv = string_to_digitals(v2, n);
            }

            string v1 = "1" + String.Join("", new int[len]);
            while (big_integer_compare(dq, dv) >= 0)
            {
                p.Add(v1);
                q = big_integer_subtract(q, v2);
                dq = string_to_digitals(q, n);
            }
        }

        d = q;

        string r = p[0];
        for (int i = 1; i < p.Count; i++)
        {
            r = big_integer_plus(r, p[i]);
        }
        return r;
    }

    #region 四则运算符（含取余数）重载

    // 运算符重载是一种常用的编程技术。
    // 用于支持“非数值类型的数据（比如类）”以常用的运算符 +-*/% 等等进行运算，使得代码简约直观。
    // 没有运算符重载的语言（比如golang）一般都不适合数值计算。

    public static BigNumber operator +(BigNumber a, BigNumber b)
    {
        return new BigNumber(big_integer_plus(a.Buffer, b.Buffer));
    }
    public static BigNumber operator -(BigNumber a, BigNumber b)
    {
        if (a > b || a == b)
            return new BigNumber(big_integer_subtract(a.Buffer, b.Buffer));
        else
            return new BigNumber(big_integer_subtract(b.Buffer, a.Buffer), "-");
    }
    public static BigNumber operator *(BigNumber a, BigNumber b)
    {
        return new BigNumber(big_integer_multiply(a.Buffer, b.Buffer));
    }
    public static BigNumber operator /(BigNumber a, BigNumber b)
    {
        return new BigNumber(big_integer_divide(a.Buffer, b.Buffer, out string _));
    }
    public static BigNumber operator %(BigNumber a, BigNumber b)
    {
        string c = big_integer_divide(a.Buffer, b.Buffer, out string d);
        return new BigNumber(d);
    }
    public static bool operator >(BigNumber a, BigNumber b)
    {
        return big_integer_compare(a.Buffer, b.Buffer) > 0;
    }
    public static bool operator <(BigNumber a, BigNumber b)
    {
        return big_integer_compare(a.Buffer, b.Buffer) < 0;
    }
    public static bool operator ==(BigNumber a, BigNumber b)
    {
        return big_integer_compare(a.Buffer, b.Buffer) == 0;
    }
    public static bool operator !=(BigNumber a, BigNumber b)
    {
        return big_integer_compare(a.Buffer, b.Buffer) != 0;
    }
    public static bool Equals(BigNumber a, BigNumber b) { return (a == b); }

    public override string ToString()
    {
        return Sign + Buffer;
    }
    #endregion
}

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

如若内容造成侵权/违法违规/事实不符，请联系我们进行投诉反馈qq邮箱809451989@qq.com，一经查实，立即删除！

相关文章

在项目中集成marsUI

在项目中集成marsUI

拷贝文件夹到目标项目 集成 安装相关依赖 npm i --save ant-design-vue4.x npm i less npm i nprogress npm i consola npm i echarts npm i vue-color-kit npm i icon-park/svg npm i vite-plugin-style-import 配置Vite文件 使用 效果
阅读更多...
Leetcode—828.统计子串中的唯一字符【困难】

Leetcode—828.统计子串中的唯一字符【困难】

2023每日刷题&#xff08;四十一&#xff09; Leetcode—828.统计子串中的唯一字符 算法思想 枚举所有种类字母在s中出现的位置&#xff0c;分别统计只包含这个字母不包含该类字母中其他字母的子串个数 实现代码 int uniqueLetterString(char* s) {int len strlen(s);cha…
阅读更多...
电子学会C/C++编程等级考试2022年06月（二级）真题解析

电子学会C/C++编程等级考试2022年06月（二级）真题解析

C/C++等级考试（1~8级）全部真题・点这里 第1题：小白鼠再排队 N只小白鼠(1 < N < 100)，每只鼠头上戴着一顶有颜色的帽子。现在称出每只白鼠的重量，要求按照白鼠重量从小到大的顺序输出它们头上帽子的颜色。帽子的颜色用 “red”，“blue”等字符串来表示。不同的小白…
阅读更多...
十分钟让你搞懂JVM中的GC垃圾回收机制(分代回收)

十分钟让你搞懂JVM中的GC垃圾回收机制(分代回收)

文章目录 0. 为什么要有垃圾回收?1. 垃圾回收哪个内存区域?2. 如何找到垃圾(死亡对象的判断)2.1 引用计数法2.2 可达性分析法2.3 两种算法的差别 3. 如何清理垃圾(死亡对象的回收)3.1 标记-清楚法3.2 复制法3.3 标记-整理法 4. JVM使用的回收方法4.1 什么是分代回收4.2 哪些对…
阅读更多...
【Linux】：信号的产生

【Linux】：信号的产生

信号 一.前台进程和后台进程1.前台进程2。后台进程3.总结 二.自定义信号动作接口三.信号的产生1.键盘组合键2.kill信号进程pid3.系统调用1.kill函数2.raise函数3.abort函数 四.异常五.软件条件六.通过终端按键产生信号 一.前台进程和后台进程 1.前台进程 一个简单的代码演示 …
阅读更多...
跟着chatgpt学习|1.spark入门

跟着chatgpt学习|1.spark入门

首先先让chatgpt帮我规划学习路径&#xff0c;使用Markdown格式返回&#xff0c;并转成思维导图的形式 目录 目录 1. 了解spark 1.1 Spark的概念 1.2 Spark的架构 1.3 Spark的基本功能 2.spark中的数据抽象和操作方式 2.1.RDD&#xff08;弹性分布式数据集&#xff09; 2…
阅读更多...
JAVA时间常用操作工具类

JAVA时间常用操作工具类

小刘整理了JAVA中对时间的常用操作&#xff0c;封装了几种方法&#xff0c;简单方便&#xff0c;开箱即用。时间转字符串格式&#xff0c;字符串转时间&#xff0c;以及过去和未来的日期。除此之外&#xff0c;还新增了时间戳之差计算时分秒天的具体方案。 public static void …
阅读更多...
【力扣：1707 1803】0-1字典树

【力扣：1707 1803】0-1字典树

思路&#xff1a;树上每个节点存储拥有该节点的数组元素的最小值&#xff0c;left节点表示0&#xff0c;right节点表示1&#xff0c;构建完成后遍历树当子节点没有比mi小的元素时直接输出-1&#xff0c;否则向下构造。 struct tree{int m;tree*leftnullptr,*rightnullptr;tree…
阅读更多...
智能优化算法应用：基于海鸥算法无线传感器网络(WSN)覆盖优化 - 附代码

智能优化算法应用：基于海鸥算法无线传感器网络(WSN)覆盖优化 - 附代码

智能优化算法应用&#xff1a;基于海鸥算法无线传感器网络(WSN)覆盖优化 - 附代码 文章目录 智能优化算法应用&#xff1a;基于海鸥算法无线传感器网络(WSN)覆盖优化 - 附代码1.无线传感网络节点模型2.覆盖数学模型及分析3.海鸥算法4.实验参数设定5.算法结果6.参考文献7.MATLAB…
阅读更多...
养生馆服务预约会员管理系统小程序效果如何

养生馆服务预约会员管理系统小程序效果如何

中医养生馆的全国数量逐渐增加&#xff0c;各种疾病困扰下&#xff0c;有些病往往通过养生馆即可治好&#xff0c;比如常见的针灸、按摩、药理滋补、切脉等&#xff0c;都有很高的市场需求度&#xff0c;而随着众多商家入局赛道及消费升级&#xff0c;传统中医养生馆经营痛点也…
阅读更多...
深度学习第3天：CNN卷积神经网络

深度学习第3天：CNN卷积神经网络

☁️主页 Nowl &#x1f525;专栏《机器学习实战》 《机器学习》 &#x1f4d1;君子坐而论道&#xff0c;少年起而行之 ​ 文章目录 介绍 CNN的主要结构 卷积层 激励层 池化层 Kears搭建CNN 搭建代码 直观感受卷积的作用 结语 介绍 卷积神经网络&#xff08;Convol…
阅读更多...
印刷基板开孔机上的直线导轨怎么安装？

印刷基板开孔机上的直线导轨怎么安装？

直线导轨是属于高精度的传动元件&#xff0c;作为印刷基板开孔机重要的传动元件&#xff0c;倘若安装不当&#xff0c;严重则无法正常作业&#xff0c;轻则影响直线导轨的精度和寿命。那么&#xff0c;印刷基板开孔机的直线导轨是如何安装的呢&#xff1f; 在安装前&#xff0c…
阅读更多...
C语言编译过程再解析

C语言编译过程再解析

多年以前,分析过编译过程,并写了一篇博客,现在对编译过程有了更广阔的认识,记录在此 编译过程 中的 链接与 编译 编译过程分为1. 预处理2. 编译3. 汇编4. 链接其中有 2个过程比较特殊,1. 编译2. 链接对于C程序来说,链接分为提前链接(静态链接)对应下图第1行运行时链接(动态链…
阅读更多...
Spring Boot 改版如何解决？使用阿里云创建项目、使用IDEA进行创建

Spring Boot 改版如何解决？使用阿里云创建项目、使用IDEA进行创建

接上次博客&#xff1a;JavaEE进阶&#xff08;2&#xff09;SpringBoot 快速上手&#xff08;环境准备、Maven&#xff1a;核心功能&#xff0c;Maven仓库、第⼀个SpringBoot程序&#xff1a;Spring介绍&#xff0c;Spring Boot介绍、创建项目&#xff09;-CSDN博客 目录 使…
阅读更多...
深度学习技巧应用30-深度学习中的GPU的基本架构原理与应用技巧

深度学习技巧应用30-深度学习中的GPU的基本架构原理与应用技巧

大家好，我是微学AI，今天给大家介绍一下深度学习技巧应用30-深度学习中的GPU的基本架构原理与应用技巧，GPU是一种专门用于处理大量并行操作的硬件设备，它的架构设计主要是为了图形渲染。然而，由于其并行处理能力，现在广泛应用于深度学习、科学计算等领域。主要的GPU制造商…
阅读更多...
智能优化算法应用：基于蝗虫算法无线传感器网络(WSN)覆盖优化 - 附代码

智能优化算法应用：基于蝗虫算法无线传感器网络(WSN)覆盖优化 - 附代码

智能优化算法应用&#xff1a;基于蝗虫算法无线传感器网络(WSN)覆盖优化 - 附代码 文章目录 智能优化算法应用&#xff1a;基于蝗虫算法无线传感器网络(WSN)覆盖优化 - 附代码1.无线传感网络节点模型2.覆盖数学模型及分析3.蝗虫算法4.实验参数设定5.算法结果6.参考文献7.MATLAB…
阅读更多...
高并发内存池

高并发内存池

1.什么是内存池 内存池动态内存分配与管理技术&#xff0c;对于程序员来说&#xff0c;通常情况下&#xff0c;动态申请内存需要使用new,delete,malloc,free这些API来申请&#xff0c;这样导致的后果是&#xff0c;当程序长时间运行之后&#xff0c;由于程序运行时所申请的内存…
阅读更多...
C#文件基本操作（判断文件是否存在、创建文件、复制或移动文件、删除文件以及获取文件基本信息）

C#文件基本操作（判断文件是否存在、创建文件、复制或移动文件、删除文件以及获取文件基本信息）

目录 一、判断文件是否存在 1.File类的Exists()方法 2.FileInfo类的Exists属性 二、创建文件 1.File类的Create()方法 2.FileInfo类的Create()方法 三、复制或移动文件 1.File类的Copy()方法 2.File类的Move()方法 3.FileInfo类的CopyTo()方法 四、删除文件 1.File…
阅读更多...
install pnpm : 无法加载文件的解决办法

install pnpm : 无法加载文件的解决办法

问题描述 我在使用pnpm的时候报错 PS D:\emss\pure-admin-backend> pnpm install pnpm : 无法加载文件 C:\Users\RD-16\AppData\Roaming\npm\pnpm.ps1。未对文件 C:\Users\RD-16\AppData\Roaming\npm\pnpm.ps1 进行数字签名。无法在当前系统上运 行该脚本。有关运行脚本和设…
阅读更多...
YOLOv5改进 | 添加SE注意力机制 + 更换NMS之EIoU-NMS

YOLOv5改进 | 添加SE注意力机制 + 更换NMS之EIoU-NMS

前言&#xff1a;Hello大家好&#xff0c;我是小哥谈。为提高算法模型在不同环境下的目标识别准确率&#xff0c;提出一种基于改进 YOLOv5 深度学习的识别方法&#xff08;SE-NMS-YOLOv5&#xff09;&#xff0c;该方法融合SE&#xff08;Squeeze-and-Excitation&#xff09;注…
阅读更多...
最新文章

Copyright @ 2022~2023

友情链接： 我的编程经验分享 一条长河网 尧图网站开发 尧图建网站