标签: physics

我想在 python 中使用 matplotlib 绘制一条粗细不同的线。

更清楚地说，我有以下变量

import matplotlib.pyplot as P 
import numpy as N

x_value = N.arange(0,10,1)
y_value = N.random.rand(10)
bandwidth = N.random.rand(10)*10
P.plot(x_value,y_value,bandwidth)

我想用 x_value 和 y_value 绘制一条线，厚度随 x_value 位置变化并由带宽向量给出。

我看到的一个可能的解决方案是绘制上下线（即我取 y_value[index] +-bandwidth[index]/2 并绘制这两条线。

然后我可以尝试填充两行之间的空间（如何？）

如果你有什么建议？

谢谢，

塞缪尔。

我正在制作炮弹射击游戏。这是我正在计算瞄准方向的简短代码。

            Vector3 mousePos = Input.mousePosition;
            mousePos.z = thisTransform.position.z - camTransform.position.z;
            mousePos = mainCamera.ScreenToWorldPoint (mousePos);

            Vector3 force = mousePos - thisTransform.position;
            force.z = force.magnitude;

这适用于球和角度 (0,0,0)。但是当角度改变时，我无法以正确的方向拍摄。

假设球和相机都在右侧看 45 度，相同的代码不起作用。

当前代码假定两者都处于角度 (0,0,0)。所以在上面提到的情况下，投掷方向总是错误的。

我想把球扔向任何方向。但假设它为 0 角并相应地抛出。

有没有办法在Matlab（特别是在R2013a中）执行第一类合流yypergeometric函数的计算？

在 Mathematica 中，这个函数被称为Hypergeometric1F1。我kummerU在 Matlab 中看到过，但定义看起来不同。

在 Mathematica 中，定义是：

在 Matlab 中，定义如下：

如何在 Matlab 中计算第一类合流超几何函数，即两个积分中的第一个？

我目前正在使用 Python3 为 Ising 模型编写代码。我对编码还很陌生。我有工作代码，但输出结果不符合预期，我似乎找不到错误。这是我的代码：

import numpy as np
import random


def init_spin_array(rows, cols):
    return np.random.choice((-1, 1), size=(rows, cols))


def find_neighbors(spin_array, lattice, x, y):
    left = (x , y - 1)
    right = (x, y + 1 if y + 1 < (lattice - 1) else 0)
    top = (x - 1, y)
    bottom = (x + 1 if x + 1 < (lattice - 1) else 0, y)

    return [spin_array[left[0], left[1]],
            spin_array[right[0], right[1]],
            spin_array[top[0], top[1]],
            spin_array[bottom[0], bottom[1]]]

def energy(spin_array, …

我正在使用简单的设置 Cannon.js，遵循在线示例，但是当我在构造函数中设置任何属性时，位置和角速度 x、y 和 z 都是 NaN。

这有效，但不会移动，因为身体没有质量。

const body = new CANNON.Body();
console.log(body.position.x, body.mass); //logs 0, 0

然而，这并不...

const body = new CANNON.Body({
    mass: 1,
});
console.log(body.position.x, body.mass); //logs NaN, 1

此外，如果我实例化身体，然后设置质量，它仍然不会移动。

更多的上下文代码（我在动画循环中调用更新函数，它正在发生）。

export const init = () => {
world = new CANNON.World();
world.gravity.set(0,1,0);
world.broadphase = new CANNON.NaiveBroadphase();
world.solver.iterations = 10;

for (let i = 0; i < BODIES_COUNT; i++) {
    const shape = new CANNON.Box(new CANNON.Vec3(4,4,4));
    const body = new CANNON.Body({
        mass: 1,
    });
    const body = …

对于我的学士论文，我正在研究一个项目，我想对一些数据进行拟合。问题有点复杂，但我试图在这里最小化问题：

我们有三个数据点（可用的理论数据很少），但这些点高度相关。

使用 curve_fit 来拟合这些点，我们得到了一个可怕的拟合结果，正如您在这张图中看到的那样。（通过手动更改拟合参数可以轻松改善拟合）。

我们的拟合结果具有相关性（蓝色）和被忽略的相关性（橙色）：

当我们使用更多参数时，结果会更好（因为那时拟合的行为本质上就像求解一样）。

我的问题：为什么会出现这种行为？（我们使用自己的最小二乘算法来解决我们的特定问题，但它也遇到了同样的问题）。这是一个数值问题，还是有什么充分的理由让 curve_fit 显示这个解决方案？

我很高兴能有一个很好的解释来说明为什么我们不能使用“仅 2 个”参数来拟合这三个高度相关的数据点。

import numpy as np
from scipy.optimize import curve_fit
import matplotlib.pyplot as plt
plt.rcParams['lines.linewidth'] = 1

y = np.array([1.1994, 1.0941, 1.0047])
w = np.array([1, 1.08, 1.16])
cor = np.array([[1, 0.9674, 0.8812],[0.9674, 1, 0.9523], [0.8812, 0.9523, 1]])
s = np.array([0.0095, 0.0104, 0.0072])

def f(x, a, b):
    return a + b*x

cov = np.zeros((3,3))
for i in range(3):
    for j in range(3):
        cov[i,j] = cor[i,j] * s[i] * s[j]

A1, …

我希望我的对象（此时是一个矩形）跳一次，在上升的过程中失去速度。当它几乎停止时，我希望它在下降的过程中掉头并获得速度。当它再次撞击地面时，它应该停止。当我再次按下该键时，它应该再次执行相同的操作。

我尝试编写的代码实现了一个变量float gravity = 0.75;和一个跟踪速度的变量float speed = 10;

当速度大于 1 时，速度应该被矩形的 Y 坐标减去，然后速度应该变低，因为我将它乘以小于 1 的重力

else if (keyCode == UP|| key == 'w') {
    while (speed >1 ) { 
      playerYPosition = playerYPosition-speed;
      speed = speed * gravity;
    }

Gravity 高于 1 但为负，因此我 substrakt 的数字在 final 中相加，矩形变小。为了获得速度，速度乘以重力。

    gravity = -1.25;
    speed = speed * gravity;
    playerYPosition = playerYPosition-speed;

速度现在应该在 -1.2 左右......，所以它小于 -1，这while(...)应该可以工作。再次它应该随着时间的推移获得速度，直到它达到起始速度，只是负面的，并以此为起点。

while (speed < -1 && speed > -10) {
      playerYPosition = playerYPosition-speed;
      speed = …

有可能将这些汽车粉碎成碎片甚至拆分.在考虑它时,他们是如何做到的？他们使用的基本算法是什么？有谁知道？

所有我都记得这款游戏有一种非常有弹性的感觉,并且它在奔腾2上运行良好.而且它看起来并不准确,只是很有趣.废弃这些车很有趣.

我想这是某种弹簧物理结合一些顶点碰撞和变换算法.你能告诉我详细资料吗？

好吧,我最近有这个功课(不用担心,我已经完成了它,但在c ++中)但我很好奇我怎么能在python中做到这一点.问题是关于发光的2个光源.我不会详细介绍.

这是代码(我在后一部分设法优化了一点):

import math, array
import numpy as np
from PIL import Image

size = (800,800)
width, height = size

s1x = width * 1./8
s1y = height * 1./8
s2x = width * 7./8
s2y = height * 7./8

r,g,b = (255,255,255)
arr = np.zeros((width,height,3))
hy = math.hypot
print 'computing distances (%s by %s)'%size,
for i in xrange(width):
    if i%(width/10)==0:
        print i,    
    if i%20==0:
        print '.',
    for j in xrange(height):
        d1 = hy(i-s1x,j-s1y)
        d2 = hy(i-s2x,j-s2y)
        arr[i][j] = …

我试图弄清楚如何将重力应用到我正在创建的应用程序中.我在Opengl有一个球体,我想要像行星一样赋予它重力.所以靠近它的任何小物体都会"掉落"到它的表面.我在网上的每一个地方都显示公式,但从不显示例子.我想知道是否有人能指出我在c ++中的一个例子的方向.我真的不想使用物理库,我希望能够看一下这个例子并从中学习以便自己理解它.