सी # में, मैं Google कैल्क की तरह मॉड्यूलस कैसे कार्यान्वित करूं?

Question

मैं एक वर्ग है जो एक आकार का प्रतिनिधित्व करता है। आकार वर्ग में एंगल नामक एक संपत्ति है। मैं इस संपत्ति के लिए सेटर को स्वचालित रूप से सीमा [0,35 9] श्रेणी में लपेटना चाहता हूं।

दुर्भाग्यवश, एक साधारण _Angle = value % 360; केवल सकारात्मक संख्याओं के लिए काम करता है। सी #, -40 % 360 == -40 में। Google कैल्क यह the way I want it करता है। मान 320 होना चाहिए।

सी # में सबसे सुरुचिपूर्ण समाधान क्या है?

 public double Angle { 
     get { return _Angle; } 
     set { 
      if (value >= 0) { 
       _Angle = value % 360; 
      } 
      else { 
       _Angle = value - (360 * ((int)(value/360) - 1)); 
      } 
     } 
    } 

संपादित करें::

धन्यवाद दोस्तों, मैं अब है:

 public double Angle { 
     get { return _Angle; } 
     set { 
      _Angle = (value % 360) + ((value < 0) ? 360 : 0); 
     } 
    } 

..Which एक बहुत है

यहाँ सबसे अच्छा तरीका है मैं अब तक मिल गया है है बेहतर :)

Answer 1

हालांकि यह जावा के लिए है, जावा भी मॉड्यूलस के लिए एक ही व्यवहार है। (यानी -40 % 360 == -40)।

नीचे दिए गए कोड को [0 से जवाब देना चाहिए। 360), दिए गए कोण, सकारात्मक या नकारात्मक के बावजूद।

public class Mod 
{ 
    public static int mod(int a, int b) 
    { 
     if (a < 0) 
      return b + (a % b); 
     else 
      return a % b; 
    } 

    public static void main(String[] args) 
    { 
     System.out.println(mod(40, 360)); // 40 
     System.out.println(mod(-40, 360)); // 320 
     System.out.println(mod(-400, 360)); // 320 
    } 
} 

ध्यान दें कि दिए गए कोण को पिछले -360 के दौरान काम करता है।

Answer 2

// go 'round once

set { _Angle = (value + 360) % 360 }

Answer 3

(360 * Math.floor(Math.abs(value)/360) + value) % 360 

Answer 4

अपने मूल्यों बेतहाशा रेंज आप एक छोटे से पाश कर सकते हैं से बाहर होने के लिए नहीं जा रहे हैं।

while (value < 0) { 
    value = value + 360; 
} 
while (value > 360) { 
    value = value - 360; 
} 

Answer 5

यह आपको आवश्यक परिणाम

public double Angle { 
    get { return _Angle; } 
    set { _Angle = value % 360 + (value % 360 < 0 : 360 : 0); } 
} 

मैं यह सोचते हैं कि 360 डिग्री है और आप को खोजने के लिए जहां में {0, 360} कोण निहित है कोशिश कर रहे हैं देना चाहिए।

Answer 6

जबकि आपका समाधान समस्या के लिए काम करता है, जबकि आपके पास एल्गोरिदम वास्तव में Google द्वारा उपयोग किए जाने वाले किसी के समान नहीं है। यदि आप नकारात्मक divisor का उपयोग करते हैं तो यह अलग है।

public double GoogleModulo(double value, double divisor) 
{ 
    long q = (long)Math.Floor(value/divisor); 
    return value - q * divisor; 
} 

Console.WriteLine(GoogleModulo( 40, 360)); // 40 
Console.WriteLine(GoogleModulo(-40, 360)); // 320 
Console.WriteLine(GoogleModulo(-400, 360)); // 320 
Console.WriteLine(GoogleModulo( 40, -360)); // -320 

अंतिम गणना here पर Google की प्रतिक्रिया की जांच करें।

एल्गोरिदम wikipedia पर समझाया गया है और डोनाल्ड Knuth के लिए जिम्मेदार है।

Answer 7

मॉड ऑपरेशन बहुत धीमा है। यदि संभव हो तो बिट मास्क के साथ प्रतिस्थापित करें।

कोबर्ड का कोड बहुत अच्छा है ... लेकिन बहुत धीमा है क्योंकि यह एक मॉड ऑपरेशन कर रहा है। यदि यह दो रेंज में से कुछ शक्ति के भीतर होने के लिए अपने डेटा पैमाने पर करने के लिए संभव है, तो आप गति लगभग द्वारा (बहुत कम 2 या 3 गुना तेजी पर) परिमाण के एक आदेश थोड़ा मुखौटा का उपयोग करके सुधार कर सकते हैं।

सी कोड:

#define BIT_MASK (0xFFFF) 
if (a < 0) { 
    return b + (a & BIT_MASK); 
} else { 
    return a & BIT_MASK; 
} 

उस समय चलाया जाता है #define कुछ बनाने के लिए स्वतंत्र महसूस। और बिट मास्क को समायोजित करने के लिए स्वतंत्र महसूस करें जो आपको दो की जरूरत है। 0xFFFFFFFF या दो की शक्ति की तरह आप कार्यान्वयन पर निर्णय लेते हैं।