c语言 sqrt 源码
时间: 2024-09-18 16:19:01 浏览: 19
C语言标准库中的math.h头文件提供了一个名为sqrt()的函数，用于计算给定实数的平方根。这个函数通常是一个数学库实现的一部分，源码细节可能会因为编译器、操作系统以及具体的实现有所不同。
下面是一个简单的`sqrt()`函数的原理示例，它使用了牛顿法（Newton's method）的大致思路，虽然这不是实际的C语言源码，但它展示了基本的概念：
```c
// 这只是一个简化版本的牛顿法求平方根
double my_sqrt(double x) {
if (x < 0) return -1; // 非正数无实数平方根
double guess = x;
while (true) {
double next_guess = (guess + x / guess) / 2.0; // 新猜测值
if (next_guess * next_guess == x) break; // 如果下一个近似值的平方等于输入值，则找到结果
guess = next_guess; // 否则更新猜测值
}
return guess;
}
```
实际上，如果你想要查看C语言的`sqrt()`函数的具体源码，那通常是系统库如glibc的一部分，这些库代码通常是二进制形式且不可直接查看。如果你想了解其工作原理，建议查阅编译器文档或者查看特定平台的公开源码（如开源的Newlib项目）。
相关问题
图像dct变换C语言源码
下面是一个简单的图像DCT变换的C语言源码：
```c
#include <stdio.h>
#include <stdlib.h>
#include <math.h>
#define N 8
void dct(double f[N][N], double F[N][N]) {
double c1, c2, sum;
int i, j, k, l;
for (i = 0; i < N; i++) {
for (j = 0; j < N; j++) {
if (i == 0) {
c1 = sqrt(1.0 / N);
} else {
c1 = sqrt(2.0 / N);
}
if (j == 0) {
c2 = sqrt(1.0 / N);
} else {
c2 = sqrt(2.0 / N);
}
sum = 0.0;
for (k = 0; k < N; k++) {
for (l = 0; l < N; l++) {
sum += f[k][l] * cos((2 * k + 1) * i * M_PI / (2 * N)) * cos((2 * l + 1) * j * M_PI / (2 * N));
}
}
F[i][j] = c1 * c2 * sum;
}
}
}
int main() {
double f[N][N] = {
{140, 144, 147, 140, 140, 155, 179, 175},
{144, 152, 140, 147, 140, 148, 167, 179},
{152, 155, 136, 167, 163, 162, 152, 172},
{168, 145, 156, 160, 152, 155, 136, 160},
{162, 148, 156, 148, 140, 136, 147, 162},
{147, 167, 140, 155, 155, 140, 136, 162},
{136, 156, 123, 167, 162, 144, 140, 147},
{148, 155, 136, 155, 152, 147, 147, 136},
};
double F[N][N];
dct(f, F);
for (int i = 0; i < N; i++) {
for (int j = 0; j < N; j++) {
printf("%lf ", F[i][j]);
}
printf("\n");
}
return 0;
}
```
这里给出的是一个基于公式计算的DCT变换实现，输入为一个8x8的二维数组，输出为另一个8x8的二维数组。在实际应用中，可能需要对变换结果进行量化和编码等处理，以实现图像压缩的目的。
动态爱心代码c语言源码
```
<!DOCTYPE html>
<html>
<head>
<title></title>
</head>
<style>
* {
padding: 0;
margin: 0;
}
html,
body {
height: 100%;
padding: 0;
margin: 0;
background: #000;
}
canvas {
position: absolute;
width: 100%;
height: 100%;
}
.aa {
position: fixed;
left: 50%;
bottom: 10px;
color: #ccc;
}
</style>
<body>
<canvas id="pinkboard"></canvas>
<script>
/*
* Settings
*/
var settings = {
particles: {
length: 500, // maximum amount of particles
duration: 2, // particle duration in sec
velocity: 100, // particle velocity in pixels/sec
effect: -0.75, // play with this for a nice effect
size: 30 // particle size in pixels
}
};
/*
* RequestAnimationFrame polyfill by Erik M?ller
*/
(function () {
var b = 0;
var c = ["ms", "moz", "webkit", "o"];
for (var a = 0; a < c.length && !window.requestAnimationFrame; ++a) {
window.requestAnimationFrame = window[c[a] + "RequestAnimationFrame"];
window.cancelAnimationFrame =
window[c[a] + "CancelAnimationFrame"] ||
window[c[a] + "CancelRequestAnimationFrame"];
}
if (!window.requestAnimationFrame) {
window.requestAnimationFrame = function (h, e) {
var d = new Date().getTime();
var f = Math.max(0, 16 - (d - b));
var g = window.setTimeout(function () {
h(d + f);
}, f);
b = d + f;
return g;
};
}
if (!window.cancelAnimationFrame) {
window.cancelAnimationFrame = function (d) {
clearTimeout(d);
};
}
})();
/*
* Point class
*/
var Point = (function () {
function Point(x, y) {
this.x = typeof x !== "undefined" ? x : 0;
this.y = typeof y !== "undefined" ? y : 0;
}
Point.prototype.clone = function () {
return new Point(this.x, this.y);
};
Point.prototype.length = function (length) {
if (typeof length == "undefined")
return Math.sqrt(this.x * this.x + this.y * this.y);
this.normalize();
this.x *= length;
this.y *= length;
return this;
};
Point.prototype.normalize = function () {
var length = this.length();
this.x /= length;
this.y /= length;
return this;
};
return Point;
})();
/*
* Particle class
*/
var Particle = (function () {
function Particle() {
this.position = new Point();
this.velocity = new Point();
this.acceleration = new Point();
this.age = 0;
}
Particle.prototype.initialize = function (x, y, dx, dy) {
this.position.x = x;
this.position.y = y;
this.velocity.x = dx;
this.velocity.y = dy;
this.acceleration.x = dx * settings.particles.effect;
this.acceleration.y = dy * settings.particles.effect;
this.age = 0;
};
Particle.prototype.update = function (deltaTime) {
this.position.x += this.velocity.x * deltaTime;
this.position.y += this.velocity.y * deltaTime;
this.velocity.x += this.acceleration.x * deltaTime;
this.velocity.y += this.acceleration.y * deltaTime;
this.age += deltaTime;
};
Particle.prototype.draw = function (context, image) {
function ease(t) {
return --t * t * t + 1;
}
var size = image.width * ease(this.age / settings.particles.duration);
context.globalAlpha = 1 - this.age / settings.particles.duration;
context.drawImage(
image,
this.position.x - size / 2,
this.position.y - size / 2,
size,
size
);
};
return Particle;
})();
/*
* ParticlePool class
*/
var ParticlePool = (function () {
var particles,
firstActive = 0,
firstFree = 0,
duration = settings.particles.duration;
function ParticlePool(length) {
// create and populate particle pool
particles = new Array(length);
for (var i = 0; i < particles.length; i++)
particles[i] = new Particle();
}
ParticlePool.prototype.add = function (x, y, dx, dy) {
particles[firstFree].initialize(x, y, dx, dy);
// handle circular queue
firstFree++;
if (firstFree == particles.length) firstFree = 0;
if (firstActive == firstFree) firstActive++;
if (firstActive == particles.length) firstActive = 0;
};
ParticlePool.prototype.update = function (deltaTime) {
var i;
// update active particles
if (firstActive < firstFree) {
for (i = firstActive; i < firstFree; i++)
particles[i].update(deltaTime);
}
if (firstFree < firstActive) {
for (i = firstActive; i < particles.length; i++)
particles[i].update(deltaTime);
for (i = 0; i < firstFree; i++) particles[i].update(deltaTime);
}
// remove inactive particles
while (
particles[firstActive].age >= duration &&
firstActive != firstFree
) {
firstActive++;
if (firstActive == particles.length) firstActive = 0;
}
};
ParticlePool.prototype.draw = function (context, image) {
// draw active particles
if (firstActive < firstFree) {
for (i = firstActive; i < firstFree; i++)
particles[i].draw(context, image);
}
if (firstFree < firstActive) {
for (i = firstActive; i < particles.length; i++)
particles[i].draw(context, image);
for (i = 0; i < firstFree; i++) particles[i].draw(context, image);
}
};
return ParticlePool;
})();
/*
* Putting it all together
*/
(function (canvas) {
var context = canvas.getContext("2d"),
particles = new ParticlePool(settings.particles.length),
particleRate =
settings.particles.length / settings.particles.duration, // particles/sec
time;
// get point on heart with -PI <= t <= PI
function pointOnHeart(t) {
return new Point(
160 * Math.pow(Math.sin(t), 3),
130 * Math.cos(t) -
50 * Math.cos(2 * t) -
20 * Math.cos(3 * t) -
10 * Math.cos(4 * t) +
25
);
}
// creating the particle image using a dummy canvas
var image = (function () {
var canvas = document.createElement("canvas"),
context = canvas.getContext("2d");
canvas.width = settings.particles.size;
canvas.height = settings.particles.size;
// helper function to create the path
function to(t) {
var point = pointOnHeart(t);
point.x =
settings.particles.size / 2 +
(point.x * settings.particles.size) / 350;
point.y =
settings.particles.size / 2 -
(point.y * settings.particles.size) / 350;
return point;
}
// create the path
context.beginPath();
var t = -Math.PI;
var point = to(t);
context.moveTo(point.x, point.y);
while (t < Math.PI) {
t += 0.01; // baby steps!
point = to(t);
context.lineTo(point.x, point.y);
}
context.closePath();
// create the fill
context.fillStyle = "#ea80b0";
context.fill();
// create the image
var image = new Image();
image.src = canvas.toDataURL();
return image;
})();
// render that thing!
function render() {
// next animation frame
requestAnimationFrame(render);
// update time
var newTime = new Date().getTime() / 1000,
deltaTime = newTime - (time || newTime);
time = newTime;
// clear canvas
context.clearRect(0, 0, canvas.width, canvas.height);
// create new particles
var amount = particleRate * deltaTime;
for (var i = 0; i < amount; i++) {
var pos = pointOnHeart(Math.PI - 2 * Math.PI * Math.random());
var dir = pos.clone().length(settings.particles.velocity);
particles.add(
canvas.width / 2 + pos.x,
canvas.height / 2 - pos.y,
dir.x,
-dir.y
);
}
// update and draw particles
particles.update(deltaTime);
particles.draw(context, image);
}
// handle (re-)sizing of the canvas
function onResize() {
canvas.width = canvas.clientWidth;
canvas.height = canvas.clientHeight;
}
window.onresize = onResize;
// delay rendering bootstrap
setTimeout(function () {
onResize();
render();
}, 10);
})(document.getElementById("pinkboard"));
</script>
</body>
</html>
```
相关推荐
最新推荐
c语言100例，非常好的c语言入门资料，有题目和大量源码
- 在程序3中，调用了`sqrt()`函数来计算平方根，这是C标准库`math.h`的一部分。计算平方根可以帮助判断一个数是否为完全平方数。 10. **输入/输出**： - 使用`printf`和`scanf`函数进行输出和输入。在程序4中，...
基于java的技术大健康综合咨询问诊平台的设计与实现.docx
基于java的技术大健康综合咨询问诊平台的设计与实现.docx
#_ssm_121_mysql_酒店管理系统_.zip
均包含代码，文章，部分项目包含ppt
#_ssm_099_mysql_花卉养殖知识平台_.zip
均包含代码，文章，部分项目包含ppt
HTML+CSS实现一个好看的动态交互效果底部导航栏源码
演示地址：https://blog.csdn.net/qq_41221596/article/details/142372140
深入理解23种设计模式
"二十三种设计模式.pdf"
在软件工程中，设计模式是解决常见问题的可重用解决方案，它们代表了在特定上下文中被广泛接受的、经过良好验证的最佳实践。以下是二十三种设计模式的简要概述，涵盖了创建型、结构型和行为型三大类别：
A. 创建型模式：
1. 单例模式（Singleton）：确保一个类只有一个实例，并提供全局访问点。避免多线程环境下的并发问题，通常通过双重检查锁定或静态内部类实现。
2. 工厂方法模式（Factory Method）和抽象工厂模式（Abstract Factory）：为创建对象提供一个接口，但允许子类决定实例化哪一个类。提供了封装变化的平台，增加新的产品族时无须修改已有系统。
3. 建造者模式（Builder）：将复杂对象的构建与表示分离，使得同样的构建过程可以创建不同的表示。适用于当需要构建的对象有多个可变部分时。
4. 原型模式（Prototype）：通过复制现有的对象来创建新对象，减少了创建新对象的成本，适用于创建相似但不完全相同的新对象。
B. 结构型模式：
5. 适配器模式（Adapter）：使两个接口不兼容的类能够协同工作。通常分为类适配器和对象适配器两种形式。
6. 代理模式（Proxy）：为其他对象提供一种代理以控制对这个对象的访问。常用于远程代理、虚拟代理和智能引用等场景。
7. 外观模式（Facade）：为子系统提供一个统一的接口，简化客户端与其交互。降低了系统的复杂度，提高了系统的可维护性。
8. 组合模式（Composite）：将对象组合成树形结构以表示“部分-整体”的层次结构。它使得客户代码可以一致地处理单个对象和组合对象。
9. 装饰器模式（Decorator）：动态地给对象添加一些额外的职责，提供了比继承更灵活的扩展对象功能的方式。
10. 桥接模式（Bridge）：将抽象部分与实现部分分离，使它们可以独立变化。实现了抽象和实现之间的解耦，使得二者可以独立演化。
C. 行为型模式：
11. 命令模式（Command）：将请求封装为一个对象，使得可以用不同的请求参数化其他对象，支持撤销操作，易于实现事件驱动。
12. 观察者模式（Observer）：定义对象间的一对多依赖关系，当一个对象的状态发生改变时，所有依赖于它的对象都会得到通知并自动更新。
13. 迭代器模式（Iterator）：提供一种方法顺序访问聚合对象的元素，而不暴露其底层表示。Java集合框架中的迭代器就是典型的实现。
14. 模板方法模式（Template Method）：定义一个操作中的算法骨架，而将一些步骤延迟到子类中。使得子类可以不改变一个算法的结构即可重定义该算法的某些特定步骤。
15. 访问者模式（Visitor）：表示一个作用于某对象结构中的各元素的操作。它可以在不改变各元素的类的前提下定义作用于这些元素的新操作。
16. 责任链模式（Chain of Responsibility）：避免将处理逻辑硬编码在一个对象中，将一系列的对象链接起来，形成一条链，沿着链传递请求，直到某个对象处理该请求。
17. 状态模式（State）：允许一个对象在其内部状态改变时改变它的行为，对象看起来似乎改变了它的类。
18. 策略模式（Strategy）：定义了一系列的算法，并将每一个算法封装起来，使它们可以相互替换。策略对象改变算法的变化，可以影响使用算法的类。
19. 备忘录模式（Memento）：在不破坏封装性的前提下，捕获一个对象的内部状态，并在该对象之外保存这个状态，以便以后恢复对象的状态。
20. 解释器模式（Interpreter）：提供一个语言的文法表示，并定义了一个解释器，用于解释语言中的句子。
设计模式是软件开发中的一种经验总结，它们可以帮助我们编写更加灵活、可扩展和可维护的代码。理解和掌握这些设计模式，对于提高软件设计能力、优化代码结构、减少重复工作具有重要意义。在实际开发中，根据具体场景选择合适的设计模式，可以使代码更具可读性和可复用性。
管理建模和仿真的文件
管理Boualem Benatallah引用此版本：布阿利姆·贝纳塔拉。管理建模和仿真。约瑟夫-傅立叶大学-格勒诺布尔第一大学，1996年。法语。NNT：电话：00345357HAL ID：电话：00345357https://theses.hal.science/tel-003453572008年12月9日提交HAL是一个多学科的开放存取档案馆，用于存放和传播科学研究论文，无论它们是否被公开。论文可以来自法国或国外的教学和研究机构，也可以来自公共或私人研究中心。L’archive ouverte pluridisciplinaire
【编程实战】：打造健壮的string to int转换函数
# 1. 转换函数的重要性与应用场景
在软件开发中，数据类型的转换是一个不可或缺的过程。特别是在处理用户输入、数据交换和数据存储时，字符串到整数（string to int）的转换函数是应用最广泛的转换操作之一。这一转换过程不仅对数据准确性至关重要，而且在确保系统性能和处理异常输入方面扮演着关键角色。
转换函数不仅仅是一个简单的数据类型转换，它还
Win11离线安装net framework 3.5方法
在Windows 11上安装.NET Framework 3.5的离线方法并不直接支持，因为Microsoft从Windows 8.1开始就停止了对.NET 3.5的正式支持，并且从Windows 10 Fall Creators Update之后不再提供.net framework的离线安装包。然而，如果你确实需要这个版本，你可以尝试以下步骤，但这可能会有一些风险：
1. **下载安装文件**：虽然官方渠道不再提供，你可以在一些技术论坛或第三方网站找到旧版的.NET Framework ISO镜像或者安装文件，但请注意这可能不是微软官方发布的，可能存在兼容性和安全性问题。
2. **创建
制作与调试：声控开关电路详解
"该资源是一份关于声控开关制作的教学资料，旨在教授读者如何制作和调试声控开关，同时涵盖了半导体三极管的基础知识，包括其工作原理、类型、测量方法和在电路中的应用。"
声控开关是一种利用声音信号来控制电路通断的装置，常用于节能照明系统。在制作声控开关的过程中，核心元件是三极管，因为三极管在电路中起到放大和开关的作用。
首先，我们需要理解三极管的基本概念。三极管是电子电路中的关键器件，分为两种主要类型：NPN型和PNP型。它们由两个PN结构成，分别是基极（b）、集电极（c）和发射极（e）。电流从发射极流向集电极，而基极控制这个电流。NPN型三极管中，电流从基极到发射极是正向的，反之对于PNP型。
在选择和测试三极管时，要关注其参数，如电流放大系数β，它决定了三极管放大电流的能力。例如，90××系列的三极管，如9013、9012、9014和9018，分别对应不同特性的NPN型和PNP型三极管。此外，还有不同封装形式，如塑料封装或金属封装，以及不同功能的标识，如开关管、低频小功率管等。
在声光控开关电路中，声控部分通常涉及麦克风或其他声音传感器，当接收到特定音量或频率的声音时，会触发信号。这个信号通过三极管进行放大，进而控制可控硅或场效应管，使电路闭合，从而开启负载（如照明设备）。照明时间控制在1分钟内，这可能涉及到延时电路的设计，如使用定时器芯片。
在实际操作中，需要用到的工具包括示波器来测量三极管的特性曲线，确保其工作在正确的区域。电路安装和调试则要求对电路原理有深入的理解，包括放大电路的分析和元件的正确连接。
制作声控开关不仅是学习电子技术的一种实践方式，也是理解半导体器件工作原理的良好途径。通过这样的项目，不仅可以提升动手能力，还能增强对基础电子学理论的理解。