ตัวเลือกใดดีกว่าที่จะใช้สำหรับหารจำนวนเต็ม 2

เทคนิคใดต่อไปนี้เป็นตัวเลือกที่ดีที่สุดสำหรับการหารจำนวนเต็ม 2 และทำไม

เทคนิค 1:

x = x >> 1;

เทคนิค 2:

x = x / 2;

นี่xคือจำนวนเต็ม

ใช้การดำเนินการที่อธิบายสิ่งที่คุณพยายามทำได้ดีที่สุด

• หากคุณปฏิบัติต่อตัวเลขเป็นลำดับของบิตให้ใช้ bitshift
• หากคุณถือว่ามันเป็นค่าตัวเลขให้ใช้การหาร

โปรดทราบว่าพวกเขาจะไม่เทียบเท่าอย่างแน่นอน พวกเขาสามารถให้ผลลัพธ์ที่แตกต่างกันสำหรับจำนวนเต็มลบ ตัวอย่างเช่น:

-5 / 2  = -2
-5 >> 1 = -3

(ideone)

คนแรกดูเหมือนจะหารไหม? x / 2ไม่ได้หากคุณต้องการที่จะแบ่งการใช้งาน คอมไพเลอร์สามารถปรับให้มันใช้บิต - กะได้ถ้าเป็นไปได้ (เรียกว่าการลดความแข็งแรง) ซึ่งทำให้การปรับขนาดเล็กแบบไร้ประโยชน์นั้นถ้าคุณทำด้วยตัวเอง

เพื่อกองบน: มีหลายเหตุผลที่จะสนับสนุนการใช้x = x / 2; นี่คือบางส่วน:

• มันเป็นการแสดงออกถึงความตั้งใจของคุณชัดเจนยิ่งขึ้น (สมมติว่าคุณไม่ได้จัดการกับบิตการลงทะเบียนบิตหรือสิ่งอื่นใด)

• คอมไพเลอร์จะลดสิ่งนี้เป็นการดำเนินการกะต่อไป

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

• หากการหารจะเป็นส่วนหนึ่งของการแสดงออกที่ใหญ่กว่าคุณมีแนวโน้มที่จะได้รับสิทธิเหนือกว่าหากคุณใช้ตัวดำเนินการหาร:

  x = x / 2 + 5;
  x = x >> 1 + 5;  // not the same as above

• เลขคณิตที่ลงนามแล้วอาจทำให้สิ่งต่าง ๆ มีความซับซ้อนยิ่งกว่าปัญหาที่มีมาก่อนดังกล่าวข้างต้น

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

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

ตัวเลือกใดเป็นตัวเลือกที่ดีที่สุดและทำไมถึงต้องหารจำนวนเต็มด้วย 2

ขึ้นอยู่กับว่าคุณหมายถึงอะไรดีที่สุดดีที่สุด

หากคุณต้องการให้เพื่อนร่วมงานเกลียดคุณหรือทำให้รหัสของคุณอ่านยากฉันจะไปกับตัวเลือกแรกอย่างแน่นอน

หากคุณต้องการหารตัวเลขด้วย 2 ให้ไปกับตัวเลขที่สอง

ทั้งสองนั้นไม่เทียบเท่ากันพวกมันจะไม่ทำงานเหมือนกันถ้าจำนวนนั้นเป็นลบหรือภายในนิพจน์ที่ใหญ่กว่า - บิตชิฟต์มีลำดับความสำคัญต่ำกว่า+หรือ-แบ่งเป็นลำดับที่สูงกว่า

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

เพียงใช้การหาร ( /) โดยสันนิษฐานว่ามันชัดเจนขึ้น คอมไพเลอร์จะปรับให้เหมาะสม

ฉันเห็นด้วยกับคำตอบอื่น ๆ ที่คุณควรได้รับ x / 2เพราะเจตนานั้นชัดเจนและผู้แปลควรปรับให้เหมาะสมสำหรับคุณ

อย่างไรก็ตามอีกเหตุผลหนึ่งที่เลือกใช้x / 2มากกว่าx >> 1นี้ก็คือพฤติกรรมของ>>การใช้งานนั้นขึ้นอยู่กับการใช้งานหากxมีการลงชื่อintและเป็นลบ

จากส่วนที่ 6.5.7, หัวข้อย่อย 5 ของมาตรฐาน ISO C99:

ผลมาจากการE1 >> E2เป็นE1ขวาขยับE2ตำแหน่งบิต ถ้าE1มีประเภทที่ได้รับการรับรองหรือถ้าE1มีการลงนามในชนิดและมูลค่าไม่ติดลบค่าของผลที่ได้เป็นส่วนหนึ่งของความฉลาดของE1/ ^E22 หากE1มีประเภทที่เซ็นชื่อและค่าลบค่าผลลัพธ์จะถูกกำหนดโดยการนำไปใช้งาน

x / 2ชัดเจนและx >> 1ไม่เร็วมาก (ตามมาตรฐานไมโคร - เร็วขึ้นประมาณ 30% สำหรับ Java JVM) ดังที่คนอื่น ๆ สังเกตไว้ว่าสำหรับจำนวนลบการปัดเศษจะแตกต่างกันเล็กน้อยดังนั้นคุณต้องพิจารณาสิ่งนี้เมื่อคุณต้องการประมวลผลจำนวนลบ คอมไพเลอร์บางคนอาจแปลงโดยอัตโนมัติx / 2เพื่อx >> 1ถ้าพวกเขารู้จำนวนที่ไม่สามารถลบ (แม้คิดว่าฉันไม่สามารถตรวจสอบได้)

แม้x / 2อาจจะไม่ได้ใช้ (ช้า) การเรียนการสอนส่วน CPU เพราะทางลัดบางส่วนจะเป็นไปได้x >> 1แต่ก็ยังช้ากว่า

(นี่คือ C / C ++ คำถามการเขียนโปรแกรมภาษาอื่น ๆ ที่มีผู้ประกอบการมากขึ้น. สำหรับ Java นอกจากนี้ยังมีการเปลี่ยนแปลงทางด้านขวาไม่ได้ลงนามx >>> 1ซึ่งจะแตกต่างอีกครั้ง. จะช่วยให้การอย่างถูกต้องคำนวณค่าเฉลี่ย (โดยเฉลี่ย) ค่าของค่าทั้งสองเพื่อให้(a + b) >>> 1น้ำพระทัย ส่งคืนค่าเฉลี่ยแม้สำหรับค่าที่มีขนาดใหญ่มากaและbนี่เป็นตัวอย่างที่จำเป็นสำหรับการค้นหาแบบไบนารีหากดัชนีอาร์เรย์สามารถมีขนาดใหญ่มากมีข้อผิดพลาดในการค้นหาแบบไบนารี่หลายรุ่นเพราะพวกเขาใช้(a + b) / 2ในการคำนวณค่าเฉลี่ย ใช้งานไม่ได้วิธีแก้ปัญหาที่ถูกต้องคือใช้(a + b) >>> 1แทน)

Knuth กล่าวว่า:

การเพิ่มประสิทธิภาพก่อนวัยอันควรเป็นรากฐานของความชั่วร้ายทั้งหมด

ดังนั้นฉันแนะนำให้ใช้ x /= 2;

วิธีนี้เป็นรหัสที่เข้าใจง่ายและฉันคิดว่าการเพิ่มประสิทธิภาพของการดำเนินการในรูปแบบนั้นไม่ได้หมายความว่าโปรเซสเซอร์จะแตกต่างกันมากนัก

ลองดูที่คอมไพเลอร์เอาต์พุตเพื่อช่วยคุณตัดสินใจ ฉันรันการทดสอบนี้ใน x86-64 ด้วย
gcc (GCC) 4.2.1 20070719 [FreeBSD]

ยังเห็นผลเรียบเรียงออนไลน์ได้ที่ godbolt

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

รหัส C พร้อมเอาต์พุตประกอบ:

สำหรับการแบ่งข้อมูลของคุณจะเป็น

int div2signed(int a) {
  return a / 2;
}

และสิ่งนี้จะคอมไพล์

    movl    %edi, %eax
    shrl    $31, %eax
    addl    %edi, %eax
    sarl    %eax
    ret

ในทำนองเดียวกันสำหรับการเปลี่ยนแปลง

int shr2signed(int a) {
  return a >> 1;
}

ด้วยเอาท์พุท:

    sarl    %edi
    movl    %edi, %eax
    ret

เพียงแค่บันทึกที่เพิ่มเข้ามา -

x * = 0.5 มักจะเร็วกว่าในภาษาที่ใช้ VM บางภาษาโดยเฉพาะ actionscript เนื่องจากตัวแปรไม่ต้องถูกตรวจสอบเพื่อหารด้วย 0

ใช้x = x / 2; หรือ x /= 2;เพราะเป็นไปได้ว่าโปรแกรมเมอร์ใหม่จะทำงานกับมันในอนาคต ดังนั้นมันจะง่ายขึ้นสำหรับเขาที่จะค้นหาสิ่งที่เกิดขึ้นในสายของรหัส ทุกคนอาจไม่ได้ตระหนักถึงการเพิ่มประสิทธิภาพดังกล่าว

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

x >> 1 จะดีกว่า x / 2 ฉันตรวจสอบบน ideone.com ด้วยการรันโปรแกรมที่มีการดำเนินการมากกว่า 10 ^ 10 ส่วนโดยการดำเนินการ 2 ครั้ง x / 2 ใช้เวลาเกือบ 5.5 วินาทีในขณะที่ x >> 1 ใช้เวลาเกือบ 2.6 วินาทีในโปรแกรมเดียวกัน

ฉันจะบอกว่ามีหลายสิ่งที่ต้องพิจารณา

1. Bitshift ควรเร็วขึ้นเนื่องจากไม่จำเป็นต้องมีการคำนวณพิเศษใด ๆ ในการเลื่อนบิตอย่างไรก็ตามตามที่กล่าวไว้มีปัญหาที่อาจเกิดขึ้นกับตัวเลขติดลบ หากคุณมั่นใจว่าจะมีตัวเลขที่เป็นบวกและกำลังมองหาความเร็วแล้วฉันจะแนะนำ bitshift

2. ตัวดำเนินการหารนั้นง่ายมากสำหรับมนุษย์ที่จะอ่าน ดังนั้นหากคุณกำลังมองหาการอ่านโค้ดคุณสามารถใช้มันได้ โปรดทราบว่าการเพิ่มประสิทธิภาพของคอมไพเลอร์มาไกลดังนั้นการทำโค้ดให้อ่านและเข้าใจได้ง่ายนั้นเป็นแนวปฏิบัติที่ดี

3. การดำเนินการอาจมีความเร็วแตกต่างกันขึ้นอยู่กับฮาร์ดแวร์ที่ใช้งาน กฎหมายของอัมดาลคือการทำให้คดีเป็นเรื่องธรรมดา ดังนั้นคุณอาจมีฮาร์ดแวร์ที่สามารถทำงานต่าง ๆ ได้เร็วกว่าอุปกรณ์อื่น ๆ ตัวอย่างเช่นการคูณด้วย 0.5 อาจเร็วกว่าการหารด้วย 2 (คุณอาจต้องใช้พื้นที่ของการคูณหากคุณต้องการบังคับใช้การหารจำนวนเต็ม)

หากคุณมีประสิทธิภาพที่แท้จริงฉันขอแนะนำให้สร้างการทดสอบบางอย่างที่สามารถทำงานได้หลายล้านครั้ง ตัวอย่างการดำเนินการหลายครั้ง (ขนาดตัวอย่างของคุณ) เพื่อกำหนดว่าอันไหนที่ดีที่สุดในเชิงสถิติด้วย OS / Hardware / Compiler / Code ของคุณ

เท่าที่ CPU มีความกังวลการดำเนินการบิตกะจะเร็วกว่าการดำเนินการแบ่ง อย่างไรก็ตามคอมไพเลอร์รู้เรื่องนี้และจะปรับให้เหมาะสมอย่างเหมาะสมที่สุดเท่าที่จะเป็นไปได้ดังนั้นคุณสามารถโค้ดในลักษณะที่เหมาะสมที่สุดและพักผ่อนได้ง่ายเมื่อรู้ว่าโค้ดของคุณทำงานอย่างมีประสิทธิภาพ แต่จำไว้ว่าunsigned intกระป๋อง (ในบางกรณี) นั้นจะได้รับการปรับปรุงให้ดีที่สุดกว่าintเหตุผลที่กล่าวมาก่อนหน้านี้ หากคุณไม่ต้องการเลขคณิตที่ลงนามแล้วอย่าใส่เครื่องหมายบิต

x = x / 2; เป็นรหัสที่เหมาะสมที่จะใช้ .. แต่การดำเนินการขึ้นอยู่กับโปรแกรมของคุณเองว่าผลลัพธ์ที่คุณต้องการผลิต

ทำให้ความตั้งใจของคุณชัดเจนขึ้น ... ตัวอย่างเช่นหากคุณต้องการหารใช้ x / 2 และให้คอมไพเลอร์ปรับแต่งมันให้เหมาะสมเพื่อเปลี่ยนโอเปอเรเตอร์ (หรืออะไรก็ได้)

โปรเซสเซอร์ของวันนี้จะไม่ยอมให้การปรับปรุงเหล่านี้มีผลกระทบใด ๆ ต่อประสิทธิภาพการทำงานของโปรแกรมของคุณ

คำตอบสำหรับสิ่งนี้จะขึ้นอยู่กับสภาพแวดล้อมที่คุณกำลังทำงานอยู่

• หากคุณกำลังทำงานกับไมโครคอนโทรลเลอร์ 8 บิตหรืออะไรก็ตามที่ไม่ได้รับการสนับสนุนจากฮาร์ดแวร์สำหรับการคูณการเลื่อนบิตเป็นสิ่งที่คาดหวังและเป็นเรื่องธรรมดาและในขณะที่คอมไพเลอร์จะกลายx /= 2เป็นx >>= 1การปรากฏตัวของสัญลักษณ์ส่วนหนึ่งจะยกคิ้วมากขึ้นในสภาพแวดล้อมที่ดีกว่า ใช้ shift เพื่อทำให้เกิดการหาร
• หากคุณกำลังทำงานในสภาพแวดล้อมที่มีความสำคัญต่อประสิทธิภาพหรือส่วนของรหัสหรือรหัสของคุณอาจถูกคอมไพล์ด้วยการเพิ่มประสิทธิภาพของคอมไพเลอร์ x >>= 1ความคิดเห็นอธิบายเหตุผลของมันอาจจะดีที่สุดเพียงเพื่อความชัดเจนของวัตถุประสงค์
• x /= 2หากคุณไม่ได้อยู่ภายใต้การเป็นหนึ่งในเงื่อนไขดังกล่าวข้างต้นทำให้รหัสของคุณอ่านได้มากขึ้นโดยเพียงแค่ใช้ ดีกว่าที่จะบันทึกโปรแกรมเมอร์ถัดไปที่เกิดขึ้นเพื่อดูรหัสของคุณ 10 วินาทีสองครั้งในการดำเนินการกะของคุณกว่าที่จะพิสูจน์ว่าคุณรู้ว่าการเปลี่ยนแปลงนั้นมีประสิทธิภาพมากขึ้น sans คอมไพเลอร์การเพิ่มประสิทธิภาพ

ทั้งหมดเหล่านี้ถือว่าเป็นจำนวนเต็มไม่ได้ลงนาม การเปลี่ยนแปลงอย่างง่ายอาจไม่ใช่สิ่งที่คุณต้องการลงชื่อ นอกจากนี้ DanielH ยังแนะนำประเด็นที่ดีเกี่ยวกับการใช้งานx *= 0.5สำหรับบางภาษาเช่น ActionScript

mod 2, การทดสอบสำหรับ = 1 เนื่องจากไวยากรณ์ใน c แต่นี่อาจเร็วที่สุด

การแบ่งการเปลี่ยนแปลงที่ถูกต้องโดยทั่วไป:

q = i >> n; is the same as: q = i / 2**n;

บางครั้งใช้เพื่อเร่งความเร็วโปรแกรมด้วยความคมชัด ฉันไม่คิดว่าคุณควรทำ คอมไพเลอร์ฉลาดพอที่จะทำการเร่งความเร็วโดยอัตโนมัติ ซึ่งหมายความว่าวางในการเปลี่ยนแปลงที่คุณไม่มีอะไรได้รับค่าใช้จ่ายของความชัดเจน

ลองดูที่หน้านี้จากการเขียนโปรแกรม C ++ ที่เป็นประโยชน์

เห็นได้ชัดว่าถ้าคุณเขียนรหัสของคุณสำหรับคนต่อไปที่อ่านให้ไปเพื่อความชัดเจนของ "x / 2"

อย่างไรก็ตามหากความเร็วเป็นเป้าหมายของคุณให้ลองทั้งผลและเวลาผลลัพธ์ไม่กี่เดือนที่ผ่านมาฉันทำงานกับรูทบิตแมปแบบ Convolution ซึ่งเกี่ยวข้องกับการก้าวผ่านอาร์เรย์จำนวนเต็มและหารแต่ละองค์ประกอบด้วย 2 ฉันได้ทำทุกอย่างเพื่อปรับให้เหมาะสมรวมถึงเคล็ดลับเก่า ๆ ของการแทน "x >> 1" สำหรับ "x / 2"

เมื่อฉันตั้งเวลาทั้งสองวิธีจริง ๆ ฉันค้นพบกับความประหลาดใจของฉันว่าx / 2 เร็วกว่า x >> 1

สิ่งนี้ใช้ Microsoft VS2008 C ++ โดยเปิดการปรับค่าเริ่มต้นไว้

ในแง่ของประสิทธิภาพ การดำเนินการกะของ CPU นั้นเร็วกว่าการแบ่ง op-code อย่างมีนัยสำคัญ ดังนั้นการหารด้วยสองหรือคูณด้วย 2 เป็นต้นทั้งหมดได้รับประโยชน์จากการดำเนินการกะ

ในฐานะที่เป็นรูปลักษณ์และความรู้สึก ในฐานะที่เป็นวิศวกรเมื่อไหร่เราถึงติดอยู่กับเครื่องสำอางที่แม้แต่ผู้หญิงสวย ๆ ก็ไม่ได้ใช้! :)

X / Y เป็นตัวดำเนินการที่ถูกต้อง ... และ ">>" ตัวดำเนินการขยับ ... หากเราต้องการให้หารสองจำนวนเต็มเราสามารถใช้ตัวดำเนินการเงินปันผล (/) shift operator ใช้เพื่อเลื่อนบิต

x = x / 2; x / = 2; เราสามารถใช้แบบนี้ ..

ในขณะที่ x >> 1 เร็วกว่า x / 2 การใช้ >> ที่เหมาะสมเมื่อจัดการกับค่าลบนั้นซับซ้อนกว่าเล็กน้อย มันต้องการสิ่งที่คล้ายกับต่อไปนี้:

// Extension Method
public static class Global {
    public static int ShiftDivBy2(this int x) {
        return (x < 0 ? x + 1 : x) >> 1;
    }
}