คำถามติดแท็ก floating-point

ฉันมีปัญหาการเพิ่มประสิทธิภาพทั่วโลกที่ไม่ท้าทายเพื่อแก้ปัญหา ปัจจุบันผมใช้กล่องเครื่องมือเพิ่มประสิทธิภาพของ MATLAB (โดยเฉพาะfmincon()กับอัลกอริทึม = 'sqp') ซึ่งมีประสิทธิภาพมาก อย่างไรก็ตามรหัสของฉันส่วนใหญ่อยู่ใน Python และฉันก็ชอบที่จะเพิ่มประสิทธิภาพใน Python ด้วยเช่นกัน มีตัวแก้ NLP ที่มีการผูก Python ที่สามารถแข่งขันได้fmincon()หรือไม่ มันจะต้อง สามารถรับมือกับความไม่เสมอภาคและความไม่เท่าเทียมกันได้ ไม่ต้องการให้ผู้ใช้จัดหายาโคบ ไม่เป็นไรหากไม่รับประกันว่าจะมีประสิทธิภาพระดับโลก ( fmincon()ไม่) fmincon()ฉันกำลังมองหาบางสิ่งบางอย่างที่ทนทานลู่ไปยังท้องถิ่นที่เหมาะสมแม้สำหรับความท้าทายปัญหาและแม้ว่ามันจะช้ากว่าเล็กน้อย ฉันได้พยายามแก้หลายที่ให้บริการผ่าน OpenOpt และพบว่าพวกเขาจะด้อยกว่าของ fmincon/sqpMATLAB เพียงเพื่อเน้นฉันมีสูตรเวิ้งว้างและแก้ปัญหาที่ดี เป้าหมายของฉันคือการเปลี่ยนภาษาเพื่อให้เวิร์กโฟลว์มีความคล่องตัวมากขึ้น เจฟฟ์ชี้ให้เห็นว่าคุณลักษณะบางอย่างของปัญหาอาจเกี่ยวข้องกัน พวกเขาคือ: 10-400 ตัวแปรการตัดสินใจ 4-100 ข้อ จำกัด ความเท่าเทียมกันของพหุนาม (ดีกรีพหุนามมีช่วงตั้งแต่ 1 ถึงประมาณ 8) จำนวนข้อ จำกัด ของความไม่เท่าเทียมกันที่มีเหตุผลเท่ากับจำนวนตัวแปรการตัดสินใจประมาณสองเท่า ฟังก์ชั่นวัตถุประสงค์เป็นหนึ่งในตัวแปรการตัดสินใจ ชาวจาโคเบียนแห่งข้อ จำกัด ความเท่าเทียมมีความหนาแน่นสูงเช่นเดียวกับชาวจาโคเบียนแห่งข้อ จำกัด …

77 python  optimization  nonlinear-programming  linear-algebra  linear-solver  sparse-matrix  ode  automatic-differentiation  efficiency  matrix  symbolic-computation  pde  multiphysics  operator-splitting  fluid-dynamics  pde  multigrid  pde  hyperbolic-pde  quadrature  precision  numerical-analysis  fluid-dynamics  interpolation  c  ode  testing  data-sets  pde  fluid-dynamics  hyperbolic-pde  pde  finite-element  fluid-dynamics  stability  incompressible  pde  hyperbolic-pde  fluid-dynamics  pde  precision  floating-point  convex-optimization  conditioning  pde  hyperbolic-pde  stability  implicit-methods  explicit-methods  fluid-dynamics  accuracy  pde  hyperbolic-pde  petsc  linear-algebra 

ฉันมีคำถามง่ายๆที่ยากสำหรับ Google (นอกเหนือจากสิ่งที่บัญญัติไว้ในสิ่งที่นักวิทยาศาสตร์คอมพิวเตอร์ทุกคนควรรู้เกี่ยวกับกระดาษคำนวณเลขทศนิยม ) เมื่อใดควรใช้ฟังก์ชันเช่นlog1pหรือexpm1ใช้แทนlogและexp? เมื่อใดที่ไม่ควรใช้ การใช้งานที่แตกต่างกันของฟังก์ชั่นเหล่านั้นแตกต่างกันอย่างไรในแง่ของการใช้งาน?

30 floating-point 

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

25 software  floating-point  accuracy 

ปัญหาที่พบบ่อยมากในมาร์คอฟเชนมอนติคาร์โลนั้นเกี่ยวข้องกับความน่าจะเป็นในการคำนวณซึ่งเป็นผลรวมของเทอมใหญ่ ๆ อีa1+ ea2+ . . .ea1+ea2+... e^{a_1} + e^{a_2} + ... ซึ่งองค์ประกอบของได้ตั้งแต่ขนาดเล็กมากที่จะมีขนาดใหญ่มาก แนวทางของฉันคือการแยกคำที่ใหญ่ที่สุดเพื่อให้:aaaK: = สูงสุดผม( กผม)K:=maxi(ai)K := \max_{i}(a_{i}) E ' ≡ อี1 + e 2 + . .a'= K+ l o g( ea1- เค+ ea2- เค+ . . . )a′=K+log(ea1−K+ea2−K+...)a' =K + log\left( e^{a_1 - K} + e^{a_2 - …

24 monte-carlo  floating-point  statistics 

ป.ร. ให้ไว้เป็นลำดับ จำกัด ที่เพิ่มขึ้นของตัวเลขบวก{n} อัลกอริทึมสองข้อใดต่อไปนี้ที่ดีกว่าสำหรับการคำนวณผลรวมของตัวเลขZ1, z2,.....znZ1,Z2,.....Znz_{1} ,z_{2},.....z_{n} s=0; for \ i=1:n s=s + z_{i} ; end หรือ: s=0; for \ i=1:n s=s + z_{n-i+1} ; end ในความคิดของฉันมันจะเป็นการดีกว่าถ้าคุณเริ่มเพิ่มตัวเลขจากจำนวนมากที่สุดไปเป็นจำนวนน้อยที่สุดเพราะข้อผิดพลาดเล็กลงเรื่อย ๆ นอกจากนี้เรายังทราบว่าเมื่อเราเพิ่มจำนวนมากเป็นจำนวนน้อยมากผลลัพธ์โดยประมาณอาจเป็นจำนวนมาก ถูกต้องหรือไม่ อะไรที่สามารถพูดได้?

22 algorithms  floating-point 

สมมติว่าฉันมีฟังก์ชั่นที่ใช้เป็นค่าหลายค่าจุดลอยตัว (เดี่ยวหรือสองครั้ง) ทำการคำนวณบางอย่างและสร้างค่าจุดลอยตัวเอาท์พุท (เช่นเดียวหรือสองครั้ง) ฉันทำงานกับ MSVC 2008 เป็นหลัก แต่ยังวางแผนที่จะทำงานกับ MinGW / GCC ฉันกำลังเขียนโปรแกรมใน C ++ อะไรคือวิธีการทั่วไปในการวัดโดยทางโปรแกรมว่ามีข้อผิดพลาดเท่าใดในผลลัพธ์ สมมติว่าฉันต้องใช้ไลบรารี่ที่มีความแม่นยำตามอำเภอใจ: อะไรคือไลบราที่ดีที่สุดถ้าฉันไม่สนใจความเร็ว?

20 floating-point  c++ 

ฉันพยายามใช้ฟังก์ชันต่อไปนี้ในทศนิยมที่มีความแม่นยำสองเท่าและมีข้อผิดพลาดสัมพัทธ์ต่ำ: l o g s u m (x,y) = บันทึก( ประสบการณ์( x ) + exp( y) )logsum(x,y)=log⁡(exp⁡(x)+exp⁡(y))\mathrm{logsum}(x,y) = \log(\exp(x) + \exp(y)) สิ่งนี้ถูกใช้อย่างกว้างขวางในแอปพลิเคชันทางสถิติเพื่อเพิ่มความน่าจะเป็นหรือความหนาแน่นของความน่าจะเป็นที่แสดงในพื้นที่บันทึก แน่นอนว่าหรือสามารถโอเวอร์โฟลว์หรืออันเดอร์โฟล์วได้ง่ายซึ่งอาจจะไม่ดีเพราะพื้นที่บันทึกถูกใช้เพื่อหลีกเลี่ยงการมีอันเดอร์โฟล์ในตอนแรก นี่เป็นวิธีแก้ปัญหาทั่วไป:exp ( y )ประสบการณ์( x )exp⁡(x)\exp(x)ประสบการณ์( y)exp⁡(y)\exp(y) l o g s u m (x,y) = x + l o g 1 p ( exp( y- x ) …

18 floating-point  stability  numerics 

ด้วยการใช้งาน BLAS สองแบบที่แตกต่างกันเราคาดหวังได้หรือไม่ว่าพวกเขาทำการคำนวณจุดลอยตัวที่แน่นอนและกลับผลลัพธ์เดียวกัน หรือสามารถเกิดขึ้นได้เช่นหนึ่งคำนวณผลิตภัณฑ์สเกลาร์เป็น และอีกหนึ่งเป็น ( x 1 y 1 + x 2 y 2 ) + ( x 3 y 3 + x 4( ( x1Y1+ x2Y2) + x3Y3) +x4Y4((x1Y1+x2Y2)+x3Y3)+x4Y4 ((x_1y_1 + x_2y_2) + x_3y_3) + x_4y_4 ดังนั้นอาจจะให้ผลที่แตกต่างกันใน IEEE ลอยคำนวณจุด?( x1Y1+ x2Y2) + ( x3Y3+ x4Y4) ,(x1Y1+x2Y2)+(x3Y3+x4Y4), (x_1y_1 + …

17 floating-point  blas 

ฉันเรียกใช้รหัสโมเลกุล (MD) GROMACSในคลัสเตอร์ Ubuntu Linux ซึ่งประกอบด้วยโหนดที่มี CPU Intel 24 Xeon จุดสนใจของฉันค่อนข้างจะอ่อนไหวต่อความแม่นยำในการคำนวณจุดลอยดังนั้นฉันต้องรัน GROMACS ด้วยความแม่นยำสองเท่าแทนที่จะใช้ความแม่นยำเดียว - แม้จะมีค่าใช้จ่ายในการคำนวณที่สูงกว่าความแม่นยำสองเท่า ดังนั้นในคลัสเตอร์ฉันได้รวบรวม GROMACS ด้วยความแม่นยำสองเท่า ฉันกำลังพิจารณาที่จะซื้อ GPU บางตัวเนื่องจากอาจมีการเร่งความเร็วญาติ ("การเร่งความเร็ว GPU") กับซีพียู อย่างไรก็ตามฉันต้องการ GPU ที่จะทำให้ฉันสามารถคำนวณเลขคณิตความแม่นยำสองเท่าได้ คุณรู้หรือไม่ว่าฮาร์ดแวร์ดังกล่าวมีวางจำหน่ายทั่วไป โพสต์ล่าสุดบน GROMACS รายชื่อผู้รับจดหมายแสดงให้เห็นว่า GPUs แม่นยำสองจะไม่สามารถใช้ได้ในเชิงพาณิชย์: ฮาร์ดแวร์ไม่รองรับ [เลขคณิตความแม่นยำสองเท่า] แต่ AFAIK นี้หน้าวิกิพีเดียดูเหมือนจะชี้ให้เห็นว่า GPUs แม่นยำสองมีการผิดปกติเนื่องจากพวกเขาอาจจะไม่มีประสิทธิภาพ: การนำไปใช้งานของ floating point บน Nvidia GPU นั้นเป็นไปตามมาตรฐาน IEEE; อย่างไรก็ตามสิ่งนี้ไม่เป็นความจริงสำหรับผู้ขายทุกราย สิ่งนี้มีความเกี่ยวข้องกับความถูกต้องซึ่งถือว่ามีความสำคัญต่อการประยุกต์ใช้ทางวิทยาศาสตร์ …

17 hpc  floating-point  molecular-dynamics  gpu 

ฉันต้องการกำหนดจำนวนทางทฤษฎีของ FLOPs (การดำเนินการจุดลอยตัว) ที่คอมพิวเตอร์ของฉันสามารถทำได้ ใครก็ได้โปรดช่วยฉันด้วยสิ่งนี้ (ฉันต้องการเปรียบเทียบคอมพิวเตอร์ของฉันกับซูเปอร์คอมพิวเตอร์บางตัวเพื่อรับทราบความแตกต่างระหว่างพวกเขา)

15 floating-point 

Let x, yมีสองจำนวนจุดลอยตัว วิธีที่ถูกต้องในการคำนวณค่าเฉลี่ยของพวกเขาคืออะไร? วิธีไร้เดียงสา(x+y)/2อาจส่งผลให้เกิดการล้นเมื่อxและyมีขนาดใหญ่เกินไป ฉันคิดว่า0.5 * x + 0.5 * yอาจจะดีกว่า แต่มันเกี่ยวข้องกับการคูณสองครั้ง (ซึ่งอาจไม่มีประสิทธิภาพ) และฉันไม่แน่ใจว่ามันดีพอ มีวิธีที่ดีกว่า? อีกความคิดหนึ่งที่ผมได้เล่นกับคือถ้า(y/2)(1 + x/y) x<=yแต่อีกครั้งฉันไม่แน่ใจว่าจะวิเคราะห์และพิสูจน์ว่าเป็นไปตามข้อกำหนดของฉัน นอกจากนี้ผมต้องรับประกันว่าค่าเฉลี่ยจะคำนวณและ>= min(x,y) <= max(x,y)ตามที่ระบุไว้ในคำตอบของ Don Hatchอาจเป็นวิธีที่ดีกว่าในการวางคำถามนี้: การใช้ค่าเฉลี่ยของตัวเลขสองตัวที่ให้ผลลัพธ์ที่แม่นยำที่สุดเท่าที่จะเป็นไปได้คืออะไร นั่นคือถ้าxและyเป็นตัวเลข floating-point จะคำนวณตัวเลข floating-point ได้(x+y)/2อย่างไร? ในกรณีนี้หมายถึงการคำนวณโดยอัตโนมัติและ>= min(x,y) <= max(x,y)ดูคำตอบของ Don Hatchสำหรับรายละเอียด หมายเหตุ:ลำดับความสำคัญของฉันคือความแม่นยำที่แข็งแกร่ง ประสิทธิภาพนั้นพอใช้ได้ อย่างไรก็ตามหากมีอัลกอริทึมที่แข็งแกร่งและแม่นยำจำนวนมากฉันจะเลือกที่มีประสิทธิภาพที่สุด

15 floating-point 

ฉันมีปัญหาในการใช้ฟังก์ชันเป็นตัวเลข มันทนทุกข์ทรมานจากความจริงที่ว่าที่ค่าอินพุตขนาดใหญ่ผลที่ได้คือจำนวนมากครั้งจำนวนมากขนาดเล็ก ฉันไม่แน่ใจว่าการยกเลิกภัยพิบัติเป็นคำที่ถูกต้องหรือไม่ดังนั้นโปรดแก้ไขให้ถูกต้องถ้าเป็นเช่นนั้น หลักฐานของสิ่งที่ผิดพลาด: ฉันจะหลีกเลี่ยงการแกว่งและการกำหนด 0.0 สำหรับอินพุตขนาดใหญ่ 6 ได้อย่างไร นี่คือหน้าที่ของฉัน: import numpy as np def func(x): t = np.exp(-np.pi*x) return 1/t*(1-np.sqrt(1-t**2))

13 python  numerical-analysis  floating-point 

ฉันอ่านหนังสือComputer Simulation of Liquidsโดย Allen และ Tildesley ผู้เขียนเริ่มจากหน้า 71 ผู้เขียนอภิปรายอัลกอริทึมต่าง ๆ ที่ใช้เพื่อรวมสมการการเคลื่อนที่ของสมการของนิวตันในการจำลองโมเลกุล (MD) ผู้เริ่มต้นในหน้า 78 ผู้เขียนอภิปรายอัลกอริทึม Verlet ซึ่งอาจเป็นอัลกอริทึมการรวมแบบบัญญัติใน MD พวกเขาระบุ: บางทีวิธีการที่ใช้กันอย่างแพร่หลายในการรวมสมการการเคลื่อนที่ก็คือการนำ Verlet (1967) มาใช้ในตอนแรกและนำมาประกอบกับ Stormer (Gear 1971) วิธีนี้เป็นวิธีการแก้ปัญหาโดยตรงของสองเพื่อสมม.ผมR¨ผม= fผมmir¨i=fim_i \ddot{\textbf{r}}_i = \textbf{f}_iฉัน วิธีนี้ขึ้นอยู่กับ postions r (t)r(t)\textbf{r}(t) , การเร่งความเร็วa (t)a(t)\textbf{a}(t)และตำแหน่งr (t-δt )r(t−δt)\textbf{r}(t - \delta t)จากขั้นตอนก่อนหน้า สมการสำหรับการเลื่อนตำแหน่งอ่านดังนี้: r (t+δt ) = 2 …

13 floating-point  computer-arithmetic 

เมื่อประเมินจำนวน FLOPs ในฟังก์ชั่นที่เรียบง่ายมักจะสามารถลงไปในการแสดงออกของผู้ประกอบการทางคณิตศาสตร์ขั้นพื้นฐานรับทราบ อย่างไรก็ตามในกรณีของคำแถลงทางคณิตศาสตร์ที่เกี่ยวข้องกับการแบ่งคู่เราไม่สามารถทำสิ่งนี้ได้และคาดว่าจะสามารถเปรียบเทียบกับ FLOP นับได้จากฟังก์ชั่นที่มีการเพิ่มเติมและการคูณเท่านั้น สถานการณ์ยิ่งแย่ลงเมื่อการดำเนินการถูกนำไปใช้ในไลบรารี ดังนั้นจึงจำเป็นที่จะต้องมีแนวคิดที่สมเหตุสมผลเกี่ยวกับประสิทธิภาพของฟังก์ชั่นพิเศษ โดยฟังก์ชั่นพิเศษเราหมายถึงสิ่งที่ชอบ: ประสบการณ์ () sqrt () บาป / cos / สีน้ำตาล () ซึ่งมักจะมีให้โดยไลบรารีระบบ การกำหนดความซับซ้อนของสิ่งเหล่านี้จะทำให้เกิดความสับสนมากยิ่งขึ้นจากข้อเท็จจริงที่ว่าหลายคนปรับตัวได้และมีความซับซ้อนขึ้นอยู่กับอินพุต ตัวอย่างเช่นการใช้งานที่มีเสถียรภาพของตัวเลข() มักจะ rescale แบบปรับตัวและใช้การค้นหา ความประทับใจครั้งแรกของฉันที่นี่คือสิ่งที่ดีที่สุดในกรณีนี้คือตรวจสอบพฤติกรรมโดยเฉลี่ยของฟังก์ชั่น แน่นอนว่าการสนทนาทั้งหมดนี้ขึ้นอยู่กับสถาปัตยกรรมเป็นอย่างมาก สำหรับการสนทนานี้เราสามารถ จำกัด ตัวเราให้เป็นสถาปัตยกรรมที่มีวัตถุประสงค์ทั่วไปแบบทั่วไปและยกเว้นสิ่งที่มีหน่วยฟังก์ชั่นพิเศษ (GPU ฯลฯ ) เราสามารถค้นหาความพยายามที่ค่อนข้างง่ายในการสร้างมาตรฐานเหล่านี้สำหรับสถาปัตยกรรมเฉพาะเพื่อประโยชน์ของระบบและการเปรียบเทียบระบบ แต่ไม่สามารถยอมรับได้หากมีใครสนใจวิธีการและประสิทธิภาพของวิธีการ วิธีการใดในการพิจารณาความซับซ้อนของ FLOP ของฟังก์ชั่นเหล่านี้ถือเป็นที่ยอมรับ มีข้อผิดพลาดที่สำคัญหรือไม่?

13 performance  complexity  floating-point 

ห้องสมุดคณิตศาสตร์ส่วนใหญ่มีฟังก์ชันลอการิทึมหลายรุ่น เวลาส่วนใหญ่เราถือว่าพวกเขาสมบูรณ์แบบ แต่จริงๆแล้วพวกเขาค่อนข้างมากแค่เสนอตัวเลขที่แน่นอน สำหรับบางฟังก์ชั่นจะมีตัวแปรที่มีความเสถียรมากกว่า ยกตัวอย่างเช่น Fortran, R, Java และ C ทั้งสองมีMath.log1pสำหรับคอมพิวเตอร์log(1.0+x)(ซึ่งข้อเสนอที่มีความแม่นยำที่สูงขึ้นสำหรับค่าเล็ก ๆ ของ x) expm1และคู่ ที่นี่ปัญหาตัวเลขเกิดขึ้นจากการสูญเสียความแม่นยำ - หากxมีขนาดเล็กจริง ๆ1.0 + xสูญเสียตัวเลขเพื่อรักษา 1 ที่จุดเริ่มต้น ฉันได้เห็นฟังก์ชั่นดังกล่าวเพื่อเพิ่มความแม่นยำในหลายสถานการณ์ สิ่งนี้ดูเหมือนจะค่อนข้างบ่อยเมื่อใดก็ตามที่คุณใช้งานฟังก์ชั่นการกระจาย (Gamma, Beta, Poisson ฯลฯ ) ด้วยความแม่นยำตัวเลขสูง logGammaยกตัวอย่างเช่นฟังก์ชันแกมมาดูเหมือนว่าจะใช้เวลาส่วนใหญ่ใช้เป็น โดยทั่วไปการไปที่ "logspace" สามารถปรับปรุงความแม่นยำได้อย่างมากดังนั้น R น่าจะมีสถานะ "logspace" ในฟังก์ชั่นส่วนใหญ่ อีกตัวอย่างหนึ่งใน R มีอยู่log1mexpสำหรับlog(1 - exp(p)): http://cran.r-project.org/web/packages/Rmpfr/vignettes/log1mexp-note.pdf ฉันเล่นกับมาตรการเอนโทรปีและข้อมูลทางทฤษฎี ศัพท์ที่พบบ่อยมากมี p * -log(p) …

11 floating-point  accuracy