90分钟实现一门编程语言——极简解释器教程

news2024/9/22 7:25:35

关键字

解释器, C#, Scheme, 函数式编程

关于

本文介绍了如何使用C#实现一个简化但全功能的Scheme方言——iScheme及其解释器，通过从零开始逐步构建，展示了编程语言/解释器的工作原理。

作者

Lucida a.k.a Luc

如果你是通过移动设备阅读本教程，或者认为本文的代码字体太小的，请使用该链接以获得更好的可读性（博客园的markdown解析器实在诡异，这里就不多吐槽了）。

提示

如果你对下面的内容感兴趣：

  • 实现基本的词法分析，语法分析并生成抽象语法树。
  • 实现嵌套作用域和函数调用。
  • 解释器的基本原理。
  • 以及一些C#编程技巧。

那么请继续阅读。

如果你对以下内容感兴趣：

  • 高级的词法/语法分析技术。
  • 类型推导/分析。
  • 目标代码优化。

本文则过于初级，你可以跳过本文，但欢迎指出本文的错误 :-)

代码样例

代码示例

public static int Add(int a, int b) {
    return a + b;
}

>> Add(3, 4)
>> 7

>> Add(5, 5)
>> 10

这段代码定义了Add函数，接下来的>>符号表示对Add(3, 4)进行求值，再下一行的>> 7表示上一行的求值结果，不同的求值用换行分开。可以把这里的>>理解成控制台提示符（即Terminal中的PS）。

什么是解释器

解释器图示

解释器（Interpreter）是一种程序，能够读入程序并直接输出结果，如上图。相对于编译器（Compiler），解释器并不会生成目标机器代码，而是直接运行源程序，简单来说：

解释器是运行程序的程序。

计算器就是一个典型的解释器，我们把数学公式（源程序）给它，它通过运行它内部的"解释器"给我们答案。

CASIO 计算器

iScheme编程语言

iScheme是什么？

  • Scheme语言的一个极简子集。
  • 虽然小，但变量，算术|比较|逻辑运算，列表，函数和递归这些编程语言元素一应俱全。
  • 非常非常慢——可以说它只是为演示本文的概念而存在。

OK，那么Scheme是什么？

  • 一种函数式程序设计语言。
  • 一种Lisp方言。
  • 麻省理工学院程序设计入门课程使用的语言（参见MIT 6.001和《计算机程序的构造与解释》）。

计算机程序的构造与解释

  • 使用波兰表达式（Polish Notation）。
  • 更多的介绍参见Scheme编程语言。

以计算阶乘为例：

C#版阶乘

public static int Factorial(int n) {
    if (n == 1) {
        return 1;
    } else {
        return n * Factorial(n - 1);
    }
}

iScheme版阶乘

(def factorial (lambda (n) (
    if (= n 1)
       1
       (* n (factorial (- n 1))))))
数值类型

由于iScheme只是一个用于演示的语言，所以目前只提供对整数的支持。iScheme使用C#的Int64类型作为其内部的数值表示方法。

定义变量

iScheme使用def关键字定义变量

>> (def a 3)
>> 3

>> a
>> 3

算术|逻辑|比较操作

与常见的编程语言（C#, Java, C++, C）不同，Scheme使用波兰表达式，即前缀表示法。例如：

C#中的算术|逻辑|比较操作

// Arithmetic ops
a + b * c
a / (b + c + d)
// Logical ops
(cond1 && cond2) || cond3
// Comparing ops
a == b
1 < a && a < 3

对应的iScheme代码

; Arithmetic ops
(+ a (* b c))
(/ a (+ b c d))
; Logical ops
(or (and cond1 cond2) cond3)
; Comparing ops
(= a b)
(< 1 a 3)

需要注意的几点：

  1. iScheme中的操作符可以接受不止两个参数——这在一定程度上控制了括号的数量。
  2. iScheme逻辑操作使用and, or和not代替了常见的&&, ||和!——这在一定程度上增强了程序的可读性。

顺序语句

iScheme使用begin关键字标识顺序语句，并以最后一条语句的值作为返回结果。以求两个数的平均值为例：

C#的顺序语句

int a = 3;
int b = 5;
int c = (a + b) / 2;

iScheme的顺序语句

(def c (begin
    (def a 3)
    (def b 5)
    (/ (+ a b) 2)))

控制流操作

iScheme中的控制流操作只包含if。

if语句示例

>> (define a (if (> 3 2) 1 2))
>> 1

>> a
>> 1
列表类型

iScheme使用list关键字定义列表，并提供first关键字获取列表的第一个元素；提供rest关键字获取列表除第一个元素外的元素。

iScheme的列表示例

>> (define alist (list 1 2 3 4))
>> (list 1 2 3 4)

>> (first alist)
>> 1

>> (rest alist)
>> (2 3 4)

定义函数

iScheme使用func关键字定义函数：

iScheme的函数定义

(def square (func (x) (* x x)))

(def sum_square (func (a b) (+ (square a) (square b))))

对应的C#代码

public static int Square (int x) {
    return x * x;
}

public static int SumSquare(int a, int b) {
    return Square(a) + Square(b);
}

递归

由于iScheme中没有for或while这种命令式语言（Imperative Programming Language）的循环结构，递归成了重复操作的唯一选择。

以计算最大公约数为例：

iScheme计算最大公约数

(def gcd (func (a b)
    (if (= b 0)
        a
        (func (b (% a b))))))

对应的C#代码

public static int GCD (int a, int b) {
    if (b == 0) {
        return a;
    } else {
        return GCD(b, a % b);
    }
}

高阶函数

和Scheme一样，函数在iScheme中是头等对象，这意味着：

  • 可以定义一个变量为函数。
  • 函数可以接受一个函数作为参数。
  • 函数返回一个函数。

iScheme的高阶函数示例

; Defines a multiply function.
(def mul (func (a b) (* a b)))
; Defines a list map function.
(def map (func (f alist)
    (if (empty? alist)
        (list )
        (append (list (f (first alist))) (map f (rest alist)))
        )))
; Doubles a list using map and mul.
>> (map (mul 2) (list 1 2 3))
>> (list 2 4 6)

小结

对iScheme的介绍就到这里——事实上这就是iScheme的所有元素，会不会太简单了？ -_-

接下来进入正题——从头开始构造iScheme的解释程序。

解释器构造

iScheme解释器主要分为两部分，解析（Parse）和求值（Evaluation）：

  • 解析（Parse）：解析源程序，并生成解释器可以理解的中间（Intermediate）结构。这部分包含词法分析，语法分析，语义分析，生成语法树。
  • 求值（Evaluation）：执行解析阶段得到的中介结构然后得到运行结果。这部分包含作用域，类型系统设计和语法树遍历。

词法分析

词法分析负责把源程序解析成一个个词法单元（Lex），以便之后的处理。

iScheme的词法分析极其简单——由于iScheme的词法元素只包含括号，空白，数字和变量名，因此C#自带的String#Split就足够。

iScheme的词法分析及测试

public static String[] Tokenize(String text) {
    String[] tokens = text.Replace("(", " ( ").Replace(")", " ) ").Split(" \t\r\n".ToArray(), StringSplitOptions.RemoveEmptyEntries);
    return tokens;
}

// Extends String.Join for a smooth API.
public static String Join(this String separator, IEnumerable<Object> values) {
    return String.Join(separator, values);
}

// Displays the lexes in a readable form.
public static String PrettyPrint(String[] lexes) {
    return "[" + ", ".Join(lexes.Select(s => "'" + s + "'") + "]";
}

// Some tests
>> PrettyPrint(Tokenize("a"))
>> ['a']

>> PrettyPrint(Tokenize("(def a 3)"))
>> ['(', 'def', 'a', '3', ')']

>> PrettyPrint(Tokenize("(begin (def a 3) (* a a))"))
>> ['begin', '(', 'def', 'a', '3', ')', '(', '*', 'a', 'a', ')', ')']
注意
  • 个人不喜欢String.Join这个静态方法，所以这里使用C#的扩展方法（Extension Methods）对String类型做了一个扩展。
  • 相对于LINQ Syntax，我个人更喜欢LINQ Extension Methods，接下来的代码也都会是这种风格。
  • 不要以为词法分析都是这么离谱般简单！vczh的词法分析教程给出了一个完整编程语言的词法分析教程。

语法树生成

得到了词素之后，接下来就是进行语法分析。不过由于Lisp类语言的程序即是语法树，所以语法分析可以直接跳过。

以下面的程序为例：

程序即语法树

;
(def x (if (> a 1) a 1))
; 换一个角度看的话：
(
    def
    x
    (
        if
        (
            >
            a
            1
        )
        a
        1
    )
)

更加直观的图片：

抽象语法树

这使得抽象语法树（Abstract Syntax Tree）的构建变得极其简单（无需考虑操作符优先级等问题），我们使用SExpression类型定义iScheme的语法树（事实上S Expression也是Lisp表达式的名字）。

抽象语法树的定义

public class SExpression {
    public String Value { get; private set; }
    public List<SExpression> Children { get; private set; }
    public SExpression Parent { get; private set; }

    public SExpression(String value, SExpression parent) {
        this.Value = value;
        this.Children = new List<SExpression>();
        this.Parent = parent;
    }

    public override String ToString() {
        if (this.Value == "(") {
            return "(" + " ".Join(Children) + ")";
        } else {
            return this.Value;
        }
    }
}

然后用下面的步骤构建语法树：

  1. 碰到左括号，创建一个新的节点到当前节点（current），然后重设当前节点。
  2. 碰到右括号，回退到当前节点的父节点。
  3. 否则把为当前词素创建节点，添加到当前节点中。

抽象语法树的构建过程

public static SExpression ParseAsIScheme(this String code) {
    SExpression program = new SExpression(value: "", parent: null);
    SExpression current = program;
    foreach (var lex in Tokenize(code)) {
        if (lex == "(") {
            SExpression newNode = new SExpression(value: "(", parent: current);
            current.Children.Add(newNode);
            current = newNode;
        } else if (lex == ")") {
            current = current.Parent;
        } else {
            current.Children.Add(new SExpression(value: lex, parent: current));
        }
    }
    return program.Children[0];
}
注意
  • 使用自动属性（Auto Property），从而避免重复编写样版代码（Boilerplate Code）。
  • 使用命名参数（Named Parameters）提高代码可读性：new SExpression(value: "", parent: null)比new SExpression("", null)可读。
  • 使用扩展方法提高代码流畅性：code.Tokenize().ParseAsIScheme比ParseAsIScheme(Tokenize(code))流畅。
  • 大多数编程语言的语法分析不会这么简单！如果打算实现一个类似C#的编程语言，你需要更强大的语法分析技术：
    • 如果打算手写语法分析器，可以参考LL(k), Precedence Climbing和Top Down Operator Precedence。
    • 如果打算生成语法分析器，可以参考ANTLR或Bison。

作用域

作用域决定程序的运行环境。iScheme使用嵌套作用域。

以下面的程序为例

>> (def x 1)
>> 1

>> (def y (begin (def x 2) (* x x)))
>> 4

>> x
>> 1

作用域示例

利用C#提供的Dictionary<TKey, TValue>类型，我们可以很容易的实现iScheme的作用域SScope：

iScheme的作用域实现

public class SScope {
    public SScope Parent { get; private set; }
    private Dictionary<String, SObject> variableTable;

    public SScope(SScope parent) {
        this.Parent = parent;
        this.variableTable = new Dictionary<String, SObject>();
    }

    public SObject Find(String name) {
        SScope current = this;
        while (current != null) {
            if (current.variableTable.ContainsKey(name)) {
                return current.variableTable[name];
            }
            current = current.Parent;
        }
        throw new Exception(name + " is not defined.");
    }

    public SObject Define(String name, SObject value) {
        this.variableTable.Add(name, value);
        return value;
    }
}

类型实现

iScheme的类型系统极其简单——只有数值，Bool，列表和函数，考虑到他们都是iScheme里面的值对象（Value Object），为了便于对它们进行统一处理，这里为它们设置一个统一的父类型SObject：

public class SObject { }
数值类型

iScheme的数值类型只是对.Net中Int64（即C#里的long）的简单封装：

public class SNumber : SObject {
    private readonly Int64 value;
    public SNumber(Int64 value) {
        this.value = value;
    }
    public override String ToString() {
        return this.value.ToString();
    }
    public static implicit operator Int64(SNumber number) {
        return number.value;
    }
    public static implicit operator SNumber(Int64 value) {
        return new SNumber(value);
    }
}

注意这里使用了C#的隐式操作符重载，这使得我们可以：

SNumber foo = 30;
SNumber bar = 40;
SNumber foobar = foo * bar;

而不必：

SNumber foo = new SNumber(value: 30);
SNumber bar = new SNumber(value: 40);
SNumber foobar = new SNumber(value: foo.Value * bar.Value);

为了方便，这里也为SObject增加了隐式操作符重载（尽管Int64可以被转换为SNumber且SNumber继承自SObject，但.Net无法直接把Int64转化为SObject）：

public class SObject {
    ...
    public static implicit operator SObject(Int64 value) {
        return (SNumber)value;
    }
}
Bool类型

由于Bool类型只有True和False，所以使用静态对象就足矣。

public class SBool : SObject {
    public static readonly SBool False = new SBool();
    public static readonly SBool True = new SBool();
    public override String ToString() {
        return ((Boolean)this).ToString();
    }
    public static implicit operator Boolean(SBool value) {
        return value == SBool.True;
    }
    public static implicit operator SBool(Boolean value) {
        return value ? True : False;
    }
}

这里同样使用了C#的隐式操作符重载，这使得我们可以：

SBool foo = a > 1;
if (foo) {
    // Do something...
}

而不用

SBool foo = a > 1 ? SBool.True: SBool.False;
if (foo == SBool.True) {
    // Do something...
}

同样，为SObject增加隐式操作符重载：

public class SObject {
    ...
    public static implicit operator SObject(Boolean value) {
        return (SBool)value;
    }
}
列表类型

iScheme使用.Net中的IEnumberable<T>实现列表类型SList：

public class SList : SObject, IEnumerable<SObject> {
    private readonly IEnumerable<SObject> values;
    public SList(IEnumerable<SObject> values) {
        this.values = values;
    }
    public override String ToString() {
        return "(list " + " ".Join(this.values) + ")";
    }
    public IEnumerator<SObject> GetEnumerator() {
        return this.values.GetEnumerator();
    }
    IEnumerator IEnumerable.GetEnumerator() {
        return this.values.GetEnumerator();
    }
}

实现IEnumerable<SObject>后，就可以直接使用LINQ的一系列扩展方法，十分方便。

函数类型

iScheme的函数类型（SFunction）由三部分组成：

  • 函数体：即对应的SExpression。
  • 参数列表。
  • 作用域：函数拥有自己的作用域

SFunction的实现

public class SFunction : SObject {
    public SExpression Body { get; private set; }
    public String[] Parameters { get; private set; }
    public SScope Scope { get; private set; }
    public Boolean IsPartial {
        get {
            return this.ComputeFilledParameters().Length.InBetween(1, this.Parameters.Length);
        }
    }

    public SFunction(SExpression body, String[] parameters, SScope scope) {
        this.Body = body;
        this.Parameters = parameters;
        this.Scope = scope;
    }

    public SObject Evaluate() {
        String[] filledParameters = this.ComputeFilledParameters();
        if (filledParameters.Length < Parameters.Length) {
            return this;
        } else {
            return this.Body.Evaluate(this.Scope);
        }
    }

    public override String ToString() {
        return String.Format("(func ({0}) {1})",
            " ".Join(this.Parameters.Select(p => {
                SObject value = null;
                if ((value = this.Scope.FindInTop(p)) != null) {
                    return p + ":" + value;
                }
                return p;
            })), this.Body);
    }

    private String[] ComputeFilledParameters() {
        return this.Parameters.Where(p => Scope.FindInTop(p) != null).ToArray();
    }
}
需要注意的几点
  • iScheme支持部分求值（Partial Evaluation），这意味着：

部分求值

>> (def mul (func (a b) (* a b)))
>> (func (a b) (* a b))

>> (mul 3 4)
>> 12

>> (mul 3)
>> (func (a:3 b) (* a b))

>> ((mul 3) 4)
>> 12

也就是说，当SFunction的实际参数（Argument）数量小于其形式参数（Parameter）的数量时，它依然是一个函数，无法被求值。

这个功能有什么用呢？生成高阶函数。有了部分求值，我们就可以使用

(def mul (func (a b) (* a b)))
(def mul3 (mul 3))

>> (mul3 3)
>> 9

而不用专门定义一个生成函数：

(def times (func (n) (func (n x) (* n x)) ) )
(def mul3 (times 3))

>> (mul3 3)
>> 9
  • SFunction#ToString可以将其自身还原为源代码——从而大大简化了iScheme的理解和测试。

内置操作

iScheme的内置操作有四种：算术|逻辑|比较|列表操作。

我选择了表达力（Expressiveness）强的lambda方法表来定义内置操作：

首先在SScope中添加静态字段builtinFunctions，以及对应的访问属性BuiltinFunctions和操作方法BuildIn。

win11跳过联网激活步骤-CSDN博客  https://blog.csdn.net/molangmolang/article/details/140187108?spm=1001.2100.3001.7377&utm_medium=distribute.pc_feed_blog_category.none-task-blog-classify_tag-5-140187108-null-null.nonecase&depth_1-utm_source=distribute.pc_feed_blog_category.none-task-blog-classify_tag-5-140187108-null-null.nonecase

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

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

相关文章

面向对象软件编程——OOP入门实践

面向对象软件编程——OOP入门实践

工作一段时间了&#xff0c;工作内容趋向于算法模型的复现&#xff0c;就是复现论文算法然后结合业务逻辑开发软件。但是在设计和开发软件时&#xff0c;发现对于OOP理念和软件的设计原则等在实战中还是非常缺乏。于是开始补习&#xff0c;基础软件开发技术。 书籍&#xff1a;…
阅读更多...
Arduino UNO 编程 第一期——下载及使用

Arduino UNO 编程 第一期——下载及使用

字幕君已上线...... 副字幕君已上线...... 计数君已上线...... 彩色字幕君 ( 花了重金请来的 ) 已上线...... Doge智能系统已上线...... Doge:嗨嗨我又来了&#xff01; 观众们......已上线&#xff01;&#xff01;&#xff01;&#xff01;&#xff01; OK LETS GO&am…
阅读更多...
理解大模型中的Cursor技术：优化长文本推理的前沿方案

理解大模型中的Cursor技术：优化长文本推理的前沿方案

理解大模型中的Cursor技术&#xff1a;优化长文本推理的前沿方案 随着自然语言处理&#xff08;NLP&#xff09;领域的快速发展&#xff0c;大型语言模型&#xff08;如GPT系列&#xff09;已广泛应用于文本生成、对话系统和复杂推理任务。然而&#xff0c;随着文本长度的增加…
阅读更多...
灾难性遗忘问题（Catastrophic Forgetting，CF）是什么？

灾难性遗忘问题（Catastrophic Forgetting，CF）是什么？

灾难性遗忘问题&#xff08;Catastrophic Forgetting&#xff0c;CF&#xff09;是什么&#xff1f; 在深度学习和人工智能领域中&#xff0c;“灾难性遗忘”&#xff08;Catastrophic Forgetting&#xff09;是指当神经网络在增量学习&#xff08;Incremental Learning&#…
阅读更多...
用AI生成旅游打卡照！FLUX假装去旅行lora的使用【附工作流】

用AI生成旅游打卡照！FLUX假装去旅行lora的使用【附工作流】

hello&#xff01;今天我们来聊聊一个特别有意思的话题&#xff1a;如何用AI生成那些看起来像是去过世界各地的旅游打卡照&#xff0c;还能在朋友圈里炫耀一番。很多人看到这些照片都会问&#xff1a;“你真的去过这些地方吗&#xff1f;” 而且最主要的是这种图片做点自媒体旅…
阅读更多...
数据仓库系列13：增量更新和全量更新有什么区别,如何选择?

数据仓库系列13：增量更新和全量更新有什么区别,如何选择?

你是否曾经在深夜加班时&#xff0c;面对着庞大的数据仓库&#xff0c;思考过这样一个问题&#xff1a;“我应该选择增量更新还是全量更新&#xff1f;” 这个看似简单的选择&#xff0c;却可能影响整个数据处理的效率和准确性。今天&#xff0c;让我们深入探讨这个数据仓库领域…
阅读更多...
RT-DETR+Sort 实现目标跟踪

RT-DETR+Sort 实现目标跟踪

在前一篇博客中&#xff0c;博主介绍了利用YOLOv8与Sort算法实现目标跟踪&#xff0c;在今天这篇博客中&#xff0c;博主将利用RT-DETR算法与Sort算法相结合&#xff0c;从而实现目标跟踪。。 这里博主依旧是采用ONNX格式的模型文件来执行推理过程&#xff0c;由于Sort算法是基…
阅读更多...
vue part6

vue part6

Vue脚手&#xff08;CLI&#xff09; 第一步&#xff08;仅第一次执行&#xff09;&#xff1a;全局安装vue/cli。 npm install -g vue/cli- 第二步&#xff1a;切换到你要创建项目的目录&#xff0c;然后使用命令创建项目vue create xxxx&#xff08;项目名字&#xff09; 第…
阅读更多...
el-table利用折叠面板 type=“expand“ 嵌套el-table，并实现 明细数据多选，选中明细数据后返回原数据得嵌套格式

el-table利用折叠面板 type=“expand“ 嵌套el-table，并实现 明细数据多选，选中明细数据后返回原数据得嵌套格式

效果图: 废话不多说直接上代码&#xff0c;完整代码展示&#xff1a; <template><el-tableborderref"multipleTable":data"tableData"tooltip-effect"dark"style"width: 100%"><el-table-columnwidth"50"la…
阅读更多...
线程池在接受到30个比较耗时的任务时的状态，在前面30个比较耗时的任务还没执行完成的情况下，再来多少个任务会触发拒绝策略？

线程池在接受到30个比较耗时的任务时的状态，在前面30个比较耗时的任务还没执行完成的情况下，再来多少个任务会触发拒绝策略？

目录 一、提出问题 二、解答 问题 1: 线程池在接受到30个比较耗时的任务时的状态 问题 2: 在前面30个比较耗时的任务还没执行完成的情况下&#xff0c;再来多少个任务会触发拒绝策略&#xff1f; 总结 一、提出问题 我们首先自定义一个线程池&#xff1a; new ThreadPoo…
阅读更多...
18042 计算分段函数值

18042 计算分段函数值

### 伪代码 1. 读取输入的实数x。 2. 根据x的值计算y&#xff1a; - 如果x < 1&#xff0c;y x。 - 如果1 < x < 10&#xff0c;y 2x - 1。 - 如果x > 10&#xff0c;y 3x - 11。 3. 输出y的值&#xff0c;保留两位小数。 ### C代码 #include <io…
阅读更多...
fl studio 21/24破解版(水果音乐制作软件24) v24.1.1.4285附安装教程

fl studio 21/24破解版(水果音乐制作软件24) v24.1.1.4285附安装教程

fl studio 21/24破解版&#xff0c;又被国内网友称之为水果音乐制作软件24&#xff0c;是Image-Line公司成立26周年而发布的一个版本&#xff0c;是目前互联网上最优秀的完整的软件音乐制作环境或数字音频工作站&#xff0c;包含了编排&#xff0c;录制&#xff0c;编辑&#x…
阅读更多...
World of Warcraft [CLASSIC][80][Grandel] Call to Arms: Warsong Gulch

World of Warcraft [CLASSIC][80][Grandel] Call to Arms: Warsong Gulch

Call to Arms: Warsong Gulch - Quest - 魔兽世界怀旧服CTM4.34《大地的裂变》数据库_大灾变85级魔兽数据库_ctm数据库 10人PVP战歌峡谷&#xff0c;该战场经常用来互刷军衔和荣誉&#xff0c;哈哈 wow plugin_魔兽世界挂机插件-CSDN博客
阅读更多...
完美解决node-sass@4.14.1 postinstall: `node scripts/build.js` 问题

完美解决node-sass@4.14.1 postinstall: `node scripts/build.js` 问题

node v14.16.0 安装node-sass4.14.1会出现报错 看日志排查发现设置的源国内的都有问题 直接梯子下载&#xff1a; https://github.com/sass/node-sass/releases/download/v4.14.1/win32-x64-83_binding.node 本地启动phpstudy&#xff0c;当然你也可以放在你服务器上&#xff0…
阅读更多...
学习笔记 ---- 数论分块（整除分块）

学习笔记 ---- 数论分块（整除分块）

文章目录 算法概述引理引理 1 1 1引理 2 2 2 数论分块结论&#xff08;区间右端点公式&#xff09;过程 N N N 维数论分块向上取整的数论分块 例题 H ( n ) H(n) H(n)[CQOI2007] 余数求和[清华集训2012] 模积和 算法 概述 数论分块可以快速计算一些含有除法向下取整的和式(即…
阅读更多...
掌握 SQL 数据操纵的基础技巧

掌握 SQL 数据操纵的基础技巧

在数据库管理中&#xff0c;SQL 数据操纵语言 (DML) 是至关重要的工具。它主要包括 INSERT、UPDATE 和 DELETE 语句&#xff0c;用于对数据库中的数据进行插入、更新和删除操作。本文将带你快速了解这些基本操作。 插入数据 在创建了一个表之后&#xff0c;最常见的操作就是插…
阅读更多...
基于SpringBoot+Vue+MySQL的的宠物商城网站

基于SpringBoot+Vue+MySQL的的宠物商城网站

系统背景 基于SpringBootVueMySQL的宠物商城网站是一个结合了现代Web开发技术的综合性电商平台&#xff0c;专为宠物爱好者及宠物商家设计。该系统背景可以从多个方面来阐述&#xff0c;包括但不限于市场需求、技术选型、用户体验以及平台价值等方面。 1. 市场需求 随着人们生…
阅读更多...
python内置模块time详解（我们需要了解的多种时间格式）

python内置模块time详解（我们需要了解的多种时间格式）

Python的time模块提供了各种与时间相关的函数。我们可以获取当前时间、操作时间日期、计算两个时间差等。 时间有两种标准表示法: 数字表示: 整数或浮点数&#xff0c;通常是自从1970年1月1日以来的秒数。9个整数组成的元组&#xff1a;元组项包含年份&#xff0c;月份&#…
阅读更多...
第 4 章 第 4 章 卷积神经网络-datawhale ai夏令营

第 4 章 第 4 章 卷积神经网络-datawhale ai夏令营

独热向量 y ′ 的长度决 定了模型可以识别出多少不同种类的东西。我们希望 y ′ 和 yˆ 的交叉熵越小越好。 为了避免过拟合&#xff0c;在做图像识别的时候&#xff0c;考虑到图像本身的特性&#xff0c;并不一定 需要全连接&#xff0c;即不需要每个神经元跟输入的每个维度都…
阅读更多...
进程通信——消息队列

进程通信——消息队列

文章目录 1.概念1.0 IPC1.1 什么是消息队列1.2 消息队列工作机制1.3 消息队列与其他进程通信机制的比较&#xff1a; 2.使用System-V版2.1 用户消息缓冲区2.2 创建消息队列msgget2.3 添加消息到消息队列msgsend2.4 从消息队列读取消息、2.5 消息队列的控制函数msgctrl2.6 msqid…
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023