คำถามติดแท็ก linear-solver

ฉันต้องการที่จะแก้ปัญหาที่ไม่ใช่เชิงเส้นด้วยข้อ จำกัด ความไม่เท่าเทียมกันเชิงเส้นและฉันใช้ลากรองจ์ที่เพิ่มขึ้นด้วยคำว่าการทำให้เป็นระเบียบแบบลงโทษซึ่งเป็นที่รู้จักกันดีคือทำลายจำนวนเงื่อนไขของระบบเชิงเส้นของฉัน . ยิ่งมีเงื่อนไขการลงโทษมากเท่าใดก็ยิ่งเลวร้ายขึ้นเท่านั้น ใครจะรู้วิธีที่มีประสิทธิภาพในการกำจัดเงื่อนไขที่ไม่ดีนี้ในกรณีที่เฉพาะเจาะจงหรือไม่ จะเจาะจงมากขึ้นฉันใช้ lagrangian เติมคลาสสิกเพราะฉันมีข้อ จำกัด มากมายซึ่งโดยทั่วไปอาจซ้ำซ้อน ดังนั้นการรวมข้อ จำกัด direclty สุ่มสี่สุ่มห้าในตัวแปรแรกจึงสะดวกมาก ฉันลองใช้วิธีการที่ซับซ้อนมากขึ้นโดยใช้การกำจัดตัวแปรหรือปัจจัยพื้นฐานที่มีประสิทธิภาพบนระบบ KKT โดยตรง แต่เนื่องจากข้อ จำกัด ที่ซ้ำซ้อนฉันจึงมีปัญหาบางอย่าง ปัญหาเกี่ยวกับตัวแปรถูกจัดทำขึ้นตามลากรองจ์ของฉันในรูปแบบ L ( U , λ ) : = W ( U ) + ρ λ Tu=[u1,⋯,un]u=[u1,⋯,un]\mathbf u =[u_1,\cdots,u_n]L(u,λ):=W(u)+ρλTc(u)+ρ2c2(u)L(u,λ):=W(u)+ρλTc(u)+ρ2c2(u)\mathcal L(\mathbf u,\lambda):= \mathcal W(\mathbf u) + \rho \lambda^T \,c(\mathbf u) …

12 linear-solver  preconditioning  constrained-optimization 

วิธี Jacobian-Free Newton-Krylov (JFNK) และวิธี Krylov โดยทั่วไปจะมีประโยชน์มากเพราะพวกเขาไม่ต้องการการจัดเก็บหรือสร้างเมทริกซ์ที่ชัดเจนเพียงผลลัพธ์ของผลิตภัณฑ์ matrix-vector หากคุณสร้างระบบที่กระจัดกระจายจริง ๆ ก็มีปัจจัยที่จำเป็นหลายอย่างสำหรับคุณ มีวิธีการใดที่ปราศจากเมทริกซ์ที่แท้จริง? Googling มีการอ้างอิงถึง "การประมาณเมทริกซ์" และมีบางสิ่งที่บ่งชี้ว่าเป็นไปได้ โดยทั่วไปวิธีการเหล่านี้ทำงานอย่างไร พวกเขาเปรียบเทียบกับผู้มีประสบการณ์ก่อนได้อย่างไร? ปัจจัยพื้นฐานที่ปราศจากเมทริกซ์ทางฟิสิกส์เป็นวิธีที่จะไปไหม? มีวิธีการใดที่ใช้ได้อย่างเปิดเผยใน wild พูดใน PETSc หรือแพ็คเกจอื่น ๆ ?

11 fluid-dynamics  linear-solver  preconditioning 

มีความหวังในการแก้ระบบเชิงเส้นต่อไปนี้อย่างมีประสิทธิภาพด้วยวิธีการวนซ้ำหรือไม่? A ∈ Rn × n, x ∈ Rn, b ∈ Rnด้วย n > 106A∈Rn×n,x∈Rn,ข∈Rnกับ n>106A \in \mathbb{R}^{n \times n}, x \in \mathbb{R}^n, b \in \mathbb{R}^n \text{, with } n > 10^6 A x = bAx=ขAx=b กับ A = ( Δ - K)A=(Δ-K) A=(\Delta - K) โดยที่ΔΔ\Deltaเป็นเมทริกซ์เบาบางมากที่มีเส้นทแยงมุมสองสามอันเกิดจาก discretization ของ Laplace …

11 linear-solver  dense-matrix  linear-system 

เมื่อพิจารณาจากระบบที่ฉันได้อ่านว่าในกรณีที่การทำซ้ำ Jacobi ถูกใช้เป็นนักแก้ปัญหาวิธีนี้จะไม่มาบรรจบกันถ้าไม่มีศูนย์ องค์ประกอบใน null พื้นที่ของ ดังนั้นวิธีหนึ่งอย่างเป็นทางการสามารถระบุได้อย่างไรว่าหากมีองค์ประกอบที่ไม่เป็นศูนย์ซึ่งประกอบไปด้วยพื้นที่ว่างของ , วิธี Jacobi นั้นไม่เป็นการรวมกัน? ฉันสงสัยว่าจะทำอย่างไรให้เป็นทางการทางคณิตศาสตร์ได้เนื่องจากส่วนหนึ่งของฉากตั้งฉากกับพื้นที่ว่างนั้นมาบรรจบกันA ∈ R n × n b A b Ax = B ,Ax=b,Ax=b,A ∈ Rn × nA∈Rn×nA\in\mathbb{R}^{n\times n}ขbbAAAขbbAAA ดังนั้นโดยการฉายช่องว่างว่างของจากแต่ละการวนซ้ำมันจะมาบรรจบกัน (หรือ?)AAA ......... ฉันสนใจเป็นพิเศษในกรณีของ ที่เป็นเมทริกซ์ Laplacian แบบสมมาตรที่มีช่องว่างว่างที่เวกเตอร์และมีองค์ประกอบเป็นศูนย์ใน null-space ของ ,ที่เป็นเมทริกซ์กึ่งกลาง นั่นหมายความว่าย้ำ Jacobi แต่ละคนจะมีช่องว่างของคาดการณ์ไว้เช่น. แต่ละ iterate จะอยู่กึ่งกลาง ? ฉันถามสิ่งนี้ตั้งแต่นั้นมาก็ไม่จำเป็นต้องฉายว่างของจาก Jacobi iterates (หรือกล่าวอีกนัยหนึ่งถึงจุดศูนย์กลางL …

11 linear-algebra  optimization  matrix  iterative-method  linear-solver 

กรุณาระบุแพ็คเกจ Python (Petsc4py ฯลฯ ... ) และตัวแก้ปัญหาแบบเบาบางโดยตรงที่รองรับ โปรดหนึ่งคำตอบ (community-wiki) ต่อแพ็คเกจ

11 python  linear-solver  sparse-matrix 

ขณะนี้ฉันกำลังทำงานเพื่อแก้ไขระบบสมมาตรขนาดใหญ่มาก (แต่ไม่แน่นอนแน่นอน) ที่สร้างขึ้นโดยอัลกอริทึมบางอย่าง เมทริกซ์เหล่านี้มีบล็อกความแจ่มใสที่ดีซึ่งสามารถใช้สำหรับการแก้แบบขนาน แต่ฉันไม่สามารถตัดสินใจได้ว่าฉันควรใช้วิธีการโดยตรง (เช่น Multi-frontal) หรือวนซ้ำ (GMRES หรือ MINRES ที่กำหนดเงื่อนไขไว้ล่วงหน้า) การศึกษาทั้งหมดของฉันแสดงให้เห็นว่าตัวแก้ซ้ำ (แม้จะมีการบรรจบกันอย่างรวดเร็วของการวนซ้ำภายใน 7 ครั้ง) ล้มเหลวในการเอาชนะผู้ปฏิบัติงานโดยตรงใน MATLAB แต่ในทางทฤษฎีแล้ววิธีการโดยตรงควรจะมีราคาสูงกว่า สิ่งนี้เกิดขึ้นได้อย่างไร? มีเอกสารหรือกระดาษที่ทันสมัยสำหรับกรณีดังกล่าวหรือไม่? ฉันสามารถใช้ sparsity แบบบล็อกในระบบคู่ขนานโดยใช้วิธีโดยตรงเช่นเดียวกับตัวแก้ซ้ำแบบยืดหยุ่นอย่าง GMRES

10 parallel-computing  linear-solver  sparse-matrix  linear-system  gmres 

ใน matlab ทั้งlinsolveและmldivideใช้สำหรับการแก้ระบบสมการเชิงเส้นในทุกกรณีที่กำหนด อ่านเอกสารของพวกเขาฉันสงสัยว่าความแตกต่างระหว่างพวกเขาคืออะไร? พวกเขาใช้อัลกอริธึมเดียวกันของการแยกตัวประกอบแบบเมทริกซ์และสามเหลี่ยมในเกือบสามกรณีหรือไม่? ถ้า A มีคุณสมบัติใน opts, linsolve จะเร็วกว่า mldivide เนื่องจาก linsolve ไม่ได้ทำการทดสอบใด ๆ เพื่อตรวจสอบว่า A มีคุณสมบัติที่ระบุ mldivide ทำการทดสอบเดียวกันเพื่อตรวจสอบว่า A มีคุณสมบัติพิเศษหรือไม่ หรือ mldivide เพียงแค่ถือว่าพวกเขาเป็นกรณีทั่วไปโดยไม่มีคุณสมบัติพิเศษ ขอบคุณ!

10 matlab  linear-solver 

ฉันต้องการทราบว่านักแก้ปัญหาเชิงเส้นคลาสสิกประเภทใด (เช่น Gauss-Seidel, Jacobi, SOR) รับประกันว่าจะมาบรรจบกันสำหรับปัญหาโดยที่คือกึ่งแน่นอนที่เป็นบวกและแน่นอนA x = bAx=ขAx=bAAAb ∈ i m ( A )ข∈ผมม.(A)b \in im(A) (ประกาศเป็นแบบกึ่งแน่นอนและไม่แน่นอน)AAA

10 linear-algebra  iterative-method  convergence  linear-solver 

ฉันได้พัฒนาวิธีการทำงานของวิธีไฟไนต์เอลิเมนต์เพื่อแก้ปัญหาการถ่ายเทความร้อนโดยใช้ GPU และ OpenCL โดยใช้วิธีการไล่ระดับสีคอนจูเกต ข้อเสียเปรียบหลักของวิธีนี้คือความต้องการหน่วยความจำสูง ยิ่งไปกว่านั้นในกรณีที่การ์ดหน่วยความจำมักจะมีข้อ จำกัด มาก ฉันเห็นสองตัวเลือก: สร้างโดเมนย่อยและแลกเปลี่ยนส่วนต่าง ๆ ของเมชด้วยหน่วยความจำโฮสต์ ใช้วิธีการแบบหลายหน้า ฉันต้องคำนึงถึงสถาปัตยกรรมที่เฉพาะเจาะจง การแลกเปลี่ยนอาจมีราคาแพงมาก วิธีการ CG เป็นที่นิยมในบริบทของการคำนวณ GPGPU แต่ฉันไม่พบการเปรียบเทียบระหว่าง CG และวิธีการแบบหลายหน้า (ในกรณีของ GPGPU) วิธีการแบบหลายหน้าสามารถทำได้เร็วกว่า CG ไหม นี่เป็นคำถามทั่วไปที่จริงแล้วมันยังขึ้นอยู่กับการใช้งาน

10 parallel-computing  opencl  linear-solver 

ฉันสนใจมากในการปรับนรกให้เหมาะสมกับการแก้ไขระบบเชิงเส้นสำหรับเมทริกซ์ขนาดเล็ก (10x10) บางครั้งเรียกว่าเมทริกซ์จิ๋ว มีวิธีแก้ปัญหาพร้อมสำหรับเรื่องนี้หรือไม่? เมทริกซ์สามารถอนุมานได้ว่าไม่มีความหมาย ตัวแก้ปัญหานี้จะต้องดำเนินการเกิน 1,000 000 ครั้งในหน่วยไมโครวินาทีบน Intel CPU ฉันกำลังพูดถึงระดับการเพิ่มประสิทธิภาพที่ใช้ในเกมคอมพิวเตอร์ ไม่ว่าฉันจะเขียนโค้ดในแอสเซมบลีและสถาปัตยกรรมเฉพาะหรือศึกษาความแม่นยำหรือความน่าเชื่อถือในการลดการแลกเปลี่ยนและใช้แฮ็กจุดลอยตัว (ฉันใช้แฟล็ก -ffast-math คอมไพล์ไม่มีปัญหา) การแก้ปัญหาอาจล้มเหลวได้ประมาณ 20% ของเวลา! partialPivLu ของ Eigen นั้นเร็วที่สุดในเบนช์มาร์กปัจจุบันของฉันมีประสิทธิภาพเหนือกว่า LAPACK เมื่อปรับให้เหมาะสมกับ -O3 และคอมไพเลอร์ที่ดี แต่ตอนนี้ฉันอยู่ที่จุดของการแก้ปัญหาเชิงเส้นกำหนดเอง คำแนะนำใด ๆ ที่จะได้รับการชื่นชมอย่างมาก ฉันจะทำให้โซลูชันของฉันเป็นโอเพ่นซอร์สและฉันจะทำมุมมองเชิงลึกที่สำคัญในสิ่งพิมพ์ ฯลฯ ที่เกี่ยวข้อง: ความเร็วในการแก้ระบบเชิงเส้นด้วยเมทริกซ์บล็อกแนวทแยง วิธีที่เร็วที่สุดในการแปลงเมทริกซ์นับล้านคืออะไร? https://stackoverflow.com/q/50909385/1489510

9 linear-algebra  linear-solver  compiling  open-source  assembly 

ฉันกำลังมองหาวิธีแก้ปัญหาเชิงเส้น 3x3 อย่างชัดเจน (กล้าพูดอย่างเหมาะสมหรือไม่) ,{3} Ax=bAx=ข\mathbf{A}\mathbf{x} = \mathbf{b}A∈R3×3,b∈R3A∈R3×3,ข∈R3\mathbf{A} \in \mathbf{R}^{3 \times 3}, \mathbf{b} \in \mathbf{R}^{3} Matrixเป็นเรื่องปกติ แต่ใกล้กับ matrix matrix ที่มีจำนวนใกล้เคียงกับ 1 เนื่องจากเป็นเซ็นเซอร์วัดจริงที่มีความแม่นยำประมาณ 5 หลักฉันไม่คิดว่าจะสูญเสียตัวเลขหลายหลักเนื่องจากตัวเลข ปัญหาAA\mathbf{A}bข\mathbf{b} แน่นอนว่าไม่ใช่เรื่องยากที่จะคิดหาวิธีแก้ปัญหาที่ชัดเจนตามวิธีการต่าง ๆ แต่ถ้ามีบางสิ่งที่แสดงให้เห็นว่าเหมาะสมที่สุดในแง่ของการนับ FLOPS นั่นจะเป็นอุดมคติ (หลังจากนั้นปัญหาทั้งหมด จะเหมาะสมกับการลงทะเบียน FP!) (ใช่กิจวัตรประจำวันนี้ถูกเรียกบ่อยครั้งฉันกำจัดผลไม้แขวนต่ำไปแล้วและนี่เป็นรายการต่อไปในรายการทำโปรไฟล์ของฉัน ... )

9 linear-solver  reference-request 

มีกฎง่ายๆที่จะบอกว่ามันคุ้มค่าที่จะทำ SOR แทน Gauss-Seidel หรือไม่? (และวิธีที่เป็นไปได้วิธีการประเมินพารามิเตอร์ realxationωω\omega) ฉันหมายถึงแค่มองดูเมทริกซ์หรือความรู้เกี่ยวกับปัญหาเฉพาะเมทริกซ์แทน? ฉันกำลังอ่านคำตอบสำหรับคำถามนี้: มีฮิวริสติกใดบ้างสำหรับการปรับวิธีการผ่อนคลายแบบต่อเนื่อง (SOR) ให้เหมาะสมหรือไม่? แต่มันซับซ้อนเกินไป ฉันไม่เห็นฮิวริสติกแบบง่าย ๆ ว่าจะประมาณรัศมีสเปกตรัมแค่มองที่เมทริกซ์ (หรือปัญหาที่มันแทน) ฉันต้องการสิ่งที่ง่ายกว่ามาก - เพียงไม่กี่ตัวอย่างของเมทริกซ์ (ปัญหา) ที่ SOR มาบรรจบกันเร็วขึ้น ฉันกำลังทดลองกับ SOR สำหรับเมทริกซ์ของกษัตริย์องค์นี้: A = I+ C+ RA=ผม+ค+RA = I + C + R ที่ไหน ผมผมI เมทริกซ์เอกลักษณ์คือ คฉันเจ= cคผมJ=คC_{ij}=c ∀ i , j∀ผม,J \forall i,j และ …

9 linear-solver  iterative-method  heuristics 

ฉันตั้งใจที่จะแก้ปัญหา Ax = b โดยที่ A มีความซับซ้อนเบาบางไม่สมมาตรและมีเงื่อนไขไม่ดี (หมายเลขเงื่อนไข ~ 1E + 20) เมทริกซ์สี่เหลี่ยมหรือสี่เหลี่ยม ฉันสามารถแก้ไขระบบด้วย ZGELSS ใน LAPACK ได้อย่างถูกต้อง แต่เมื่อระดับความเป็นอิสระในระบบของฉันเพิ่มขึ้นมันใช้เวลานานในการแก้ไขระบบบนพีซีที่มี ZGELSS เนื่องจาก sparsity ไม่ถูกใช้ประโยชน์ เมื่อเร็ว ๆ นี้ฉันลอง SuperLU (ใช้ที่เก็บข้อมูล Harwell-Boeing) สำหรับระบบเดียวกัน แต่ผลลัพธ์ไม่ถูกต้องสำหรับหมายเลขเงื่อนไข> 1E + 12 (ฉันไม่แน่ใจว่านี่เป็นปัญหาเชิงตัวเลขกับการหมุน) ฉันมีแนวโน้มที่จะใช้ตัวแก้ปัญหาที่พัฒนาแล้วมากขึ้น มีตัวแก้ปัญหาที่แข็งแกร่งซึ่งสามารถแก้ปัญหาระบบที่ฉันกล่าวถึงอย่างรวดเร็ว (เช่นการใช้ประโยชน์จาก sparsity) และเชื่อถือได้ (ในมุมมองของหมายเลขเงื่อนไข)?

9 linear-solver  sparse-matrix  lapack  condition-number 

ฉันต้องแก้ Ax = b แต่ฉันรู้ว่าแม้ว่าจะเบาบาง แต่การจัดเก็บค่าสัมประสิทธิ์เมทริกซ์ของปัญหาของฉันจะใช้หน่วยความจำมากเกินไป ดังนั้นตอนนี้ฉันกำลังพิจารณาใช้วิธีการแบบปราศจากเมทริกซ์เนื่องจากค่าสัมประสิทธิ์เดียวกันปรากฏขึ้นเป็นจำนวนมากเวลาในเมทริกซ์ดังนั้นฉันจึงสามารถใช้รูปแบบการจัดเก็บข้อมูลส่วนตัวของฉันเอง (และเพิ่มประสิทธิภาพแคช) ฉันกำลังมองหา Petsc ซึ่งให้ส่วนต่อประสานสำหรับตัวดำเนินการเชิงเส้นแบบปราศจากเมทริกซ์ แต่สิ่งที่ฉันไม่เข้าใจจริง ๆ แล้วเป็นวิธีการคำนวณล่วงหน้าโดย petc หรือไม่? หรือฉันควรจัดให้มีเงื่อนไขเบื้องต้นของฉันเอง? ถ้าเป็นเช่นนั้นจะมีเครื่องมือหรือผู้รับในการสร้างตัวสร้างเงื่อนไขล่วงหน้าจากตัวดำเนินการเชิงเส้นแบบปราศจากเมทริกซ์หรือไม่? ข้อมูลเพิ่มเติมเกี่ยวกับโอเปอเรเตอร์ของฉัน: มันไม่สมมาตร, ไม่เป็นแนวทแยงมุม, แต่ครอบงำด้วย sidebands ไม่กี่อัน (แต่มันไม่ใช่แถบสีในแนวทแยง)

9 linear-solver  petsc  sparse-operator 

การเขียนโปรแกรมส่วนใหญ่ของฉันเป็นรหัสการวิจัยแบบครั้งเดียวใน C สำหรับการใช้งานของฉันเอง ฉันไม่เคยแจกจ่ายรหัสใด ๆ ให้แก่ผู้อื่นนอกเหนือจากผู้ทำงานร่วมกันอย่างใกล้ชิด ฉันได้พัฒนาอัลกอริทึมที่ฉันกำลังตีพิมพ์ในวารสารทางวิทยาศาสตร์ ฉันต้องการที่จะให้รหัสที่มาและบางทีรหัสที่ปฏิบัติการได้ในภาคผนวกออนไลน์ของบทความ เพื่อนร่วมงานขอให้ฉันทำการวางนัยสำหรับอัลกอริทึมที่ต้องการให้ฉันเขียนใน C ++ (แอ๊!) และต้องการให้ฉันแก้ระบบเชิงเส้นหนาแน่นขนาดเล็ก หากฉันประสบความสำเร็จในการรับฐานผู้ใช้สำหรับอัลกอริทึมมันจะเป็นส่วนหนึ่งเนื่องจากแถบรายการเพื่อใช้งานอยู่ในระดับต่ำ (เช่นบนพื้น) ผู้ใช้ที่มีศักยภาพจะไม่ติดตั้งไลบรารี ฯลฯ เพื่อใช้รหัส ฉันต้องการรหัสที่จะยืนอยู่คนเดียวอย่างเต็มที่และไม่มีภาระผูกพันโดยใบอนุญาตใด ๆ เลย ฉันอาจจะเขียนแก้ปัญหาของตัวเองโดยเอาบางอย่างออกจาก Golub และ van Loan แต่ฉันควรใช้ตัวแก้วนิลาที่คนอื่นเขียนไปแล้วถ้ามี ข้อเสนอแนะชื่นชม ขอบคุณ!

9 linear-solver  libraries  c++  c