एक सामान्य रैखिक इंटरपोलेटर: डेटटाइम से कैसे निपटें?

Question

मैं एक लीनियरइंटरपोलेटर वर्ग लिखना चाहता हूं, जहां एक्स एक्स अक्ष मान का प्रकार है, और वाई वाई अक्ष मान का प्रकार है। मैं यह नहीं देख सकता कि ऐसा कैसे करें कि एक्स डेटटाइम या डबल हो सकता है। वर्ग नीचे की तरह कुछ (जो अपरीक्षित है):

class LinearInterpolator<X, Y> 
{ 
    private List<X> m_xAxis; 
    private List<Y> m_yAxis; 

    public LinearInterpolator(List<X> x, List<Y> y) 
    { 
     m_xAxis = x; 
     m_yAxis = y; 
    } 

    public Y interpolate(X x) 
    { 
     int i = m_xAxis.BinarySearch(x); 
     if (i >= 0) 
     { 
      return m_yAxis[i]; 
     } 
     else 
     { 
      // Must interpolate. 
      int rightIdx = ~i; 
      if (rightIdx >= m_xAxis.Count) 
       --rightIdx; 
      int leftIdx = rightIdx - 1; 

      X xRight = m_xAxis[rightIdx]; 
      X xLeft = m_xAxis[leftIdx]; 
      Y yRight = m_yAxis[rightIdx]; 
      Y yLeft = m_yAxis[leftIdx]; 

      // This is the expression I'd like to write generically. 
      // I'd also like X to be compilable as a DateTime. 
      Y y = yLeft + ((x - xLeft)/(xRight - xLeft)) * (yRight - yLeft); 
      return y; 
     } 
    } 
} 

}

यह C++ आसान होगा, लेकिन मैं इतना किसी भी मदद की सराहना की जाएगी सी # जेनरिक के लिए नया हूँ।

Answer 1

इंटरप्रोलेटेड मान के रूप में DateTime.Ticks का उपयोग करें। आप long प्रकार का उपयोग अपने सामान्य के रूप में समय के बीच इंटरपोलेट करने के लिए कर सकते हैं।

Answer 2

एक बात यह जानना है कि सी # ऑपरेटर ओवरराइड का समर्थन नहीं करता है। तो ऐसा कोड काम नहीं करता है।

स्पोलसन के रूप में एक समाधान ने जेनिक्स का उपयोग नहीं किया है, और टी के बजाय int या long का उपयोग करना है, और डेटटाइम का उपयोग करें।

Y y = FromDouble<Y>(ToDouble(yLeft) + ((ToDouble(x) - ToDouble(xLeft))/
      (ToDouble(xRight) - ToDouble(xLeft))) * 
      (ToDouble(yRight) - ToDouble(yLeft))); 

double ToDouble(object val) 
{ 
    if (val is DateTime) 
     return (double)((DateTime)val).Ticks; 
    else 
     return Convert.ToDouble(val); 
} 

T FromDouble<T>(double val) 
{ 
    if (typeof(T) == typeof(DateTime)) 
     return (T)Convert.ChangeType(new DateTime((long)val), typeof(T)); 
    else 
     return (T)Convert.ChangeType(val, typeof(T)); 
} 

मैं कोड का परीक्षण नहीं किया है, इसलिए यह छद्म कोड पर विचार करें:

Answer 3

वहाँ सी # जेनरिक से गणित करने के लिए कोई अच्छा तरीका है, तो आप कुछ इस तरह क्या करना है।

Answer 4

सलाह के लिए धन्यवाद। मैं अपना दृष्टिकोण बदल रहा हूं और एक इंटरपोलेटर लिख रहा हूं जो केवल युगल के लिए काम करता है; मैं इंटरपोलेशन तेज़ होना चाहता हूं, इसलिए रन-टाइम पर टाइप चेक न करना पसंद करते हैं।