Explicit Euler method ช้าเกินไปสำหรับปัญหาการเกิดปฏิกิริยา

ฉันกำลังแก้ไขระบบตอบโต้การแพร่ของทัวริงด้วยรหัส C ++ ต่อไปนี้ ช้าเกินไป: สำหรับพื้นผิวพิกเซล 128x128 จำนวนการวนซ้ำที่ยอมรับได้คือ 200 - ซึ่งส่งผลให้เกิดความล่าช้า 2.5 วินาที ฉันต้องการ 400 ซ้ำเพื่อให้ได้ภาพที่น่าสนใจ - แต่ 5 วินาทีของการรอนั้นมากเกินไป นอกจากนี้ขนาดของพื้นผิวควรเป็นจริง 512x512 - แต่มันส่งผลในเวลาที่รอคอยมาก อุปกรณ์คือ iPad, iPod

มีโอกาสที่จะทำสิ่งนี้ได้เร็วขึ้นไหม? วิธีออยเลอร์ลู่เข้าช้า (วิกิพีเดีย) - การมีวิธีที่เร็วกว่าจะทำให้จำนวนการทำซ้ำลดลงหรือไม่

แก้ไข:ตามที่โธมัสคลิมเพลชี้ให้เห็นบรรทัด: "ถ้า (m_An [i] [j] <0.0) {... }", "ถ้า (m_Bn [i] [j] <0.0) {... }" มีการล่าช้าในการบรรจบ: หลังจากลบภาพที่มีความหมายปรากฏขึ้นหลังจาก75 ซ้ำ ฉันได้แสดงความคิดเห็นออกบรรทัดในรหัสด้านล่าง

void TuringSystem::solve( int iterations, double CA, double CB ) {
    m_iterations = iterations;
    m_CA = CA;
    m_CB = CB;

    solveProcess();
}

void set_torus( int & x_plus1, int & x_minus1, int x, int size ) {
    // Wrap "edges"
    x_plus1 = x+1;
    x_minus1 = x-1;
    if( x == size - 1 ) { x_plus1 = 0; }
    if( x == 0 ) { x_minus1 = size - 1; }
}

void TuringSystem::solveProcess() {
    int n, i, j, i_add1, i_sub1, j_add1, j_sub1;
    double DiA, ReA, DiB, ReB;

    // uses Euler's method to solve the diff eqns
    for( n=0; n < m_iterations; ++n ) {
        for( i=0; i < m_height; ++i ) {
            set_torus(i_add1, i_sub1, i, m_height);

            for( j=0; j < m_width; ++j ) {
                set_torus(j_add1, j_sub1, j, m_width);

                // Component A
                DiA = m_CA * ( m_Ao[i_add1][j] - 2.0 * m_Ao[i][j] + m_Ao[i_sub1][j]   +   m_Ao[i][j_add1] - 2.0 * m_Ao[i][j] + m_Ao[i][j_sub1] );
                ReA = m_Ao[i][j] * m_Bo[i][j] - m_Ao[i][j] - 12.0;
                m_An[i][j] = m_Ao[i][j] + 0.01 * (ReA + DiA);
                // if( m_An[i][j] < 0.0 ) { m_An[i][j] = 0.0; }

                // Component B
                DiB = m_CB * ( m_Bo[i_add1][j] - 2.0 * m_Bo[i][j] + m_Bo[i_sub1][j]   +   m_Bo[i][j_add1] - 2.0 * m_Bo[i][j] + m_Bo[i][j_sub1] );
                ReB = 16.0 - m_Ao[i][j] * m_Bo[i][j];
                m_Bn[i][j] = m_Bo[i][j] + 0.01 * (ReB + DiB);
                // if( m_Bn[i][j] < 0.0 ) { m_Bn[i][j]=0.0; }
            }
        }

        // Swap Ao for An, Bo for Bn
        swapBuffers();
    }
}

ดูเหมือนว่าคุณจะถูก จำกัด ด้วยความมั่นคงซึ่งคาดว่าเนื่องจากการแพร่กระจายนั้นแข็งเมื่อคุณปรับแต่งกริด วิธีการที่ดีสำหรับระบบที่แข็งเป็นส่วนน้อย จะใช้ความพยายามบ้าง แต่คุณสามารถใช้อัลกอริธึม multigrid แบบง่าย ๆ (หรือใช้ไลบรารี) เพื่อแก้ปัญหาระบบนี้ด้วยค่าใช้จ่ายน้อยกว่า "หน่วยงาน" สิบหน่วย เมื่อคุณปรับแต่งกริดจำนวนการวนซ้ำจะไม่เพิ่มขึ้น

จากมุมมองที่ใช้งานได้จริง: โปรเซสเซอร์ A5 ไม่ได้มีประสิทธิภาพมากนักดังนั้นคุณสามารถรอการทำซ้ำ HW สองสามครั้งหรือหาก iPod / iPad ของคุณกำลังเชื่อมต่อกับอินเทอร์เน็ตแก้ปัญหาของคุณจากระยะไกลหรือในระบบคลาวด์

ออยเลอร์เข้าหากันอย่างช้าๆเมื่อเทียบกับวิธีอื่น ๆ แต่ฉันไม่คิดว่าเป็นสิ่งที่คุณสนใจ หากคุณกำลังมองหาภาพที่ "น่าสนใจ" เพิ่มขนาดของขั้นตอนเวลาและทำซ้ำให้น้อยลง ปัญหาดังที่ Jed ชี้ให้เห็นก็คือเมธอดออยเลอร์อย่างชัดเจนมีปัญหาด้านความมั่นคงกับขั้นตอนเวลาขนาดใหญ่ที่สัมพันธ์กับขนาดกริด ยิ่งกริดของคุณมีขนาดเล็กลง (เช่นความละเอียดของภาพที่สูงขึ้น) ขั้นตอนเวลาที่เล็กลงของคุณจะต้องพิจารณาด้วย

ตัวอย่างเช่นโดยใช้ euler โดยปริยายแทนชัดแจ้งคุณจะไม่ได้รับคำสั่งของการบรรจบกัน แต่โซลูชันจะมีเสถียรภาพที่ไม่มีเงื่อนไขช่วยให้ขั้นตอนเวลามีขนาดใหญ่ขึ้น วิธีการโดยนัยนั้นมีความซับซ้อนมากขึ้นในการติดตั้งและใช้การคำนวณต่อขั้นตอนมากขึ้น แต่คุณควรเห็นผลกำไรที่ดีกว่านั้นโดยทำตามขั้นตอนทั้งหมดน้อยกว่า