小编Zac*_*ack的帖子

到目前为止,我的函数找到3个数字的中位数并对它们进行排序,但它总是进行三次比较.我想我可以在某处使用嵌套的if语句,这样有时我的函数只会进行两次比较.

int median_of_3(int list[], int p, int r)
{
    int median = (p + r) / 2;

    if(list[p] > list[r])
        exchange(list, p, r);
    if(list[p] > list[median])
        exchange(list, p, median);
    if(list[r] > list[median])
        exchange(list, r, median);

    comparisons+=3;                // 3 comparisons for each call to median_of_3

    return list[r];
}

我不确定我在哪里可以看到嵌套的if语句.

我试图将我的Python/Numpy代码转换为Cython代码以加速.但是,Cython比Python/Numpy代码慢很多(3-4倍).我正确使用Cython吗？我在Cython代码中正确地将参数传递给myc_rb_etc()吗？当我调用集成函数时呢？预先感谢您的帮助.这是我的Python/Numpy代码:

from pylab import * 
import pylab as pl
from numpy import *
import numpy as np
from scipy import integrate

def myc_rb_e2f(y,t,k,d):

    M = y[0]
    E = y[1]
    CD = y[2]
    CE = y[3]
    R = y[4]
    RP = y[5] 
    RE = y[6]

    S = 0.01
    if t > 300:
        S = 5.0
    #if t > 400
        #S = 0.01

    t1 = k[0]*S/(k[7]+S);
    t2 = k[1]*(M/(k[14]+M))*(E/(k[15]+E));
    t3 = k[5]*M/(k[14]+M);
    t4 = k[11]*CD*RE/(k[16]+RE);
    t5 = k[12]*CE*RE/(k[17]+RE);
    t6 = k[2]*M/(k[14]+M);
    t7 …

我在通过Scipy&Numpy将我的MATLAB代码翻译成Python时遇到了一些麻烦.我坚持如何找到我的ODE系统的最佳参数值(k0和k1),以适应我的十个观察数据点.我目前对k0和k1有一个初步猜测.在MATLAB中,我可以使用一种叫做"fminsearch"的东西,它是一个接受ODE系统,观察数据点和ODE系统初始值的函数.然后,它将计算一对新的参数k0和k1,它们将适合观察到的数据.我已经包含了我的代码,看看你是否可以帮助我实现某种"fminsearch"来找到适合我数据的最佳参数值k0和k1.我想将任何代码添加到我的lsqtest.py文件中.

我有三个.py文件 - ode.py,lsq.py和lsqtest.py

ode.py:

def f(y, t, k): 
return (-k[0]*y[0],
      k[0]*y[0]-k[1]*y[1],
      k[1]*y[1])

lsq.py:

import pylab as py
import numpy as np
from scipy import integrate
from scipy import optimize
import ode
def lsq(teta,y0,data):
    #INPUT teta, the unknowns k0,k1
    # data, observed 
    # y0 initial values needed by the ODE
    #OUTPUT lsq value

    t = np.linspace(0,9,10)
    y_obs = data #data points
    k = [0,0]
    k[0] = teta[0]
    k[1] = teta[1]

    #call the ODE solver to get the states:
    r = …

我有一些运行缓慢的 Python/Numpy 代码，我认为这是因为使用了双循环。这是代码。

def heat(D,u0,q,tdim):
    xdim = np.size(u0)
    Z = np.zeros([xdim,tdim])
    Z[:,0]=u0;
    for i in range(1,tdim):
        for j in range (1,xdim-1):
            Z[j,i]=Z[j,i-1]+D*q*(Z[j-1,i-1]-2*Z[j,i-1]+Z[j+1,i-1])
    return Z

我正在尝试删除双 for 循环并将 Z 向量化。这是我的尝试。

def heat(D,u0,q,tdim):
    xdim = np.size(u0)
    Z = np.zeros([xdim,tdim])
    Z[:,0]=u0;
    Z[1:,1:-1]=Z[1:-1,:-1]+D*q*(Z[:-2,:-1]-2*Z[1:-1,:-1]+Z[2:,:-1])
    return Z

这不起作用 - 我收到以下错误：

operands could not be broadcast together with shapes (24,73) (23,74)

所以在尝试矢量化 Z 的某个地方，我搞砸了。你能帮我找出我的错误吗？

我正在尝试生成从对数正态分布中获取的10000个随机数,其相关的正态分布具有均值= 0.3和std.开发.在MATLAB中= 0.05.

我正在使用内置lognrnd功能.

我的尝试是:

R = lognrnd(0.3,0.05,10000,1)

然而,当我绘制的直方图R使用hist(R),相关的情节是正常的,不正常的日志.

我搞砸了哪里？如果平均值= 0.3和标准.开发.= 0.05的正态分布,不应该生成的对数正态数具有均值= 0.3和std.dev = 0.05？

多谢你们.

我试图实现动态编程方法来找到两个序列之间的最长公共子序列。当被比较的两个字符串长度相同时，我的算法有效，但是当第二个字符串比第一个字符串长时，我的LCSLength()函数不会返回正确的值。

这是带有返回错误值的测试用例的代码。

#include <iostream>
#include <string>
#include <fstream>

using namespace std;

int LCSLength(string X,string Y);

int main()
{
    string first ("HELLO");
    string second ("HLOCKKE");
    int LCS;

    //ifstream inData;
    //inData.open("test.dat");

    //inData >> first >> second;
    //inData.close();

    LCS = LCSLength(first,second);
    cout << "The LCS is: " << LCS << endl;
    cout << first << endl;
    cout << second << endl;
    return 0;
}

int LCSLength(string X,string Y)
{
    int m = X.size();
    int n = Y.size();
    int C[m][n];
    for(int i=0; …

我对插入排序的实现似乎是在排序第一个元素的例外.我这里有一个小测试用例.谁能告诉我算法有什么问题？

#include <iostream>
#include <string>
#include <stdlib.h>
using namespace std;



void Insert(int *S, int k)
{
        int key = S[k];
        int j = k-1;
        while(j>0 && S[j] > key)
        {
                S[j+1] = S[j];
                j--;
        }

        S[j+1] = key;
}


void Insertionsort(int S[], int n)
{
        if(n>1)
                Insertionsort(S,n-1);
        Insert(S,n);

}

int main()
{
        srand ( time(NULL) );
        int S1_8[8];
        for(int i=0; i<8; i++)
                S1_8[i] = rand()%100;

        Insertionsort(S1_8,8);

        for(int i=0; i<8; i++)
        {
                cout << S1_8[i] << endl;
        }

        return 0;
}

我试图将一些Python/Numpy代码转换为Cython以加快速度.这是我的代码:

cimport numpy as np
import numpy as np
from numpy import *
import pylab as pl
from pylab import * 
from scipy import integrate

def myc_rb_e2f(np.ndarray[double,ndim=1] y = np.zeros(7),double t, double k,double d):

    M = y[0]
    E = y[1]
    CD = y[2]
    CE = y[3]
    R = y[4]
    RP = y[5] 
    RE = y[6]

    cdef double S = 0.01
    if t > 300.0:
        S = 5.0
    #if t > 400
        #S = 0.01

    cdef double t1 = k[0]*S/(k[7]+S)
    cdef …

已经很晚了 - 我无法找到我的错误在我的error功能中.我正在尝试参数估计.

function value = lv(t,y,p)
    %Lotka-Volterra Model
    %p(1)=a, p(2) = b, p(3) = c, p(4) = r.
    value = [-p(1)*y(1)-p(2)*y(1)*y(2);-p(4)*y(2)+p(3)*y(1)*y(2)];
end

function error = lverr(p)
    %LVERR: Function defining error function for
    %example with Lotka-Volterra equations.
    H = [30.0 47.2 70.2 77.4 36.3 20.6 18.1 21.4 22 25.4 27.1];
    L = [4 6.1 9.8 35.2 59.4 41.7 19 13 8.3 9.1 7.4];

    [t,y] = ode45(@lv,[0 10],[H(1);L(1)],[],p);
    value = (y(:,1)-H').^2+(y(:,2)-L').^2;
    %Primes transpose data vectors H and L
    error …

我在下面有两个不同的快速排序实现.我已经验证了这些版本的quicksort工作的意义,他们将对我正确给出的任何数组进行排序.如果您注意到(至少在我看来),当阵列大小n大于8 时,版本#2与版本#1完全相同.因此,我希望当我给这两个函数提供相同的数组时如果大小大于8,它们应该平均进行相同数量的组件比较,但它们不会.

对于n > 8,功能使用sort3()和partition()功能.我已经列出了以下内容,以向您展示我如何计算组件明智比较的数量.

我知道,W(n)这些快速排序实现的理论最坏情况比较是(n(n + 2)/ 4)+8.因此,对于数组大小n = 500,W(n) = 62758.对于大小数组的测试运行n = 500,版本#1平均进行大约5000次比较,这是合理的.但是,版本#2平均进行80000次比较.显然这不是正确的 - 版本#2正在进行比理论更多的比较,W(n)并且它与(版本#1)完全相同(至少在我看来).

您是否看到我在版本#2中出现的错误？

版本#1:

void Quicksort_M3(int S[], int low, int hi)
{
    if(low < hi)
    {
        if((low+1) == hi)
        {
            comparisons++;
            if(S[low] > S[hi])
                swap(S[low],S[hi]);
        }
        else
        {
            Sort3(S,low,hi);
            if((low+2)<hi)
            {
                swap(S[low+1],S[(low+hi)/2]);
                int q = partition(S, low+1, hi-1);
                Quicksort_M3(S, low, q-1);
                Quicksort_M3(S, q+1, hi);
            }
        }
    } …