तून Krijthe द्वारा जवाब ज्यादातर समय काम करता है। लेकिन कभी-कभी यह अधिक संख्या में टिक्स का उत्पादन करेगा। यह नकारात्मक संख्या के साथ भी काम नहीं करेगा। समस्या के लिए ओवरआल दृष्टिकोण ठीक है लेकिन इसे संभालने का एक बेहतर तरीका है। आप जिस एल्गोरिथ्म का उपयोग करना चाहते हैं, वह इस बात पर निर्भर करेगा कि आप वास्तव में क्या पाना चाहते हैं। नीचे मैं आपको अपना कोड प्रस्तुत कर रहा हूं जिसका उपयोग मैंने अपने जेएस प्लॉटिंग लाइब्रेरी में किया था। मैंने इसका परीक्षण किया है और यह हमेशा काम करता है (उम्मीद है;))। यहाँ प्रमुख कदम हैं:
- वैश्विक चरम xMin और xMax प्राप्त करें (उन सभी भूखंडों को हटा दें जिन्हें आप एल्गोरिथ्म में प्रिंट करना चाहते हैं)
- xMin और xMax के बीच की गणना रेंज
- अपनी सीमा के परिमाण के क्रम की गणना करें
- टिकों की संख्या के आधार पर श्रेणी को विभाजित करके टिक आकार की गणना करें
- यह एक वैकल्पिक है। यदि आप शून्य टिक ऑलवेज प्रिंट करना चाहते हैं तो आप सकारात्मक और नकारात्मक टिकों की संख्या की गणना करने के लिए टिक आकार का उपयोग करें। टिक्स की कुल संख्या उनकी राशि + 1 होगी (शून्य टिक)
- यदि आपके पास शून्य टिक ऑलवेज मुद्रित है, तो इसकी आवश्यकता नहीं है। कम और ऊपरी बाध्य की गणना करें लेकिन भूखंड को केंद्र में रखना याद रखें
चलो शुरू करते हैं। पहले बुनियादी गणना
var range = Math.abs(xMax - xMin); //both can be negative
var rangeOrder = Math.floor(Math.log10(range)) - 1;
var power10 = Math.pow(10, rangeOrder);
var maxRound = (xMax > 0) ? Math.ceil(xMax / power10) : Math.floor(xMax / power10);
var minRound = (xMin < 0) ? Math.floor(xMin / power10) : Math.ceil(xMin / power10);
मैं न्यूनतम और अधिकतम मानों को 100% सुनिश्चित करता हूं कि मेरा प्लॉट सभी डेटा को कवर करेगा। रेंज व्हीटर के लॉग 10 को फर्श करना बहुत महत्वपूर्ण है या नहीं यह नकारात्मक है और 1 बाद में घटिया होता है। अन्यथा आपका एल्गोरिदम उन संख्याओं के लिए काम नहीं करेगा जो एक से कम हैं।
var fullRange = Math.abs(maxRound - minRound);
var tickSize = Math.ceil(fullRange / (this.XTickCount - 1));
//You can set nice looking ticks if you want
//You can find exemplary method below
tickSize = this.NiceLookingTick(tickSize);
//Here you can write a method to determine if you need zero tick
//You can find exemplary method below
var isZeroNeeded = this.HasZeroTick(maxRound, minRound, tickSize);
मैं 7, 13, 17 आदि जैसे टिक्स से बचने के लिए "गुड लुकिंग टिक्स" का उपयोग करता हूं। यहां मैं जिस विधि का उपयोग करता हूं वह बहुत सरल है। जरूरत पड़ने पर जीरो टिक करना भी अच्छा है। प्लॉट इस तरह से बहुत अधिक पेशेवर लगता है। आपको इस उत्तर के अंत में सभी विधियाँ मिलेंगी।
अब आपको ऊपरी और निचले सीमा की गणना करनी होगी। यह शून्य टिक के साथ बहुत आसान है, लेकिन अन्य मामले में थोड़ा अधिक प्रयास की आवश्यकता है। क्यों? क्योंकि हम प्लॉट को ऊपरी और निचले हिस्से में अच्छी तरह से बांधना चाहते हैं। मेरे कोड पर एक नज़र है। कुछ चर इस दायरे के बाहर परिभाषित किए गए हैं और उनमें से कुछ एक वस्तु के गुण हैं जिसमें संपूर्ण प्रस्तुत कोड रखा गया है।
if (isZeroNeeded) {
var positiveTicksCount = 0;
var negativeTickCount = 0;
if (maxRound != 0) {
positiveTicksCount = Math.ceil(maxRound / tickSize);
XUpperBound = tickSize * positiveTicksCount * power10;
}
if (minRound != 0) {
negativeTickCount = Math.floor(minRound / tickSize);
XLowerBound = tickSize * negativeTickCount * power10;
}
XTickRange = tickSize * power10;
this.XTickCount = positiveTicksCount - negativeTickCount + 1;
}
else {
var delta = (tickSize * (this.XTickCount - 1) - fullRange) / 2.0;
if (delta % 1 == 0) {
XUpperBound = maxRound + delta;
XLowerBound = minRound - delta;
}
else {
XUpperBound = maxRound + Math.ceil(delta);
XLowerBound = minRound - Math.floor(delta);
}
XTickRange = tickSize * power10;
XUpperBound = XUpperBound * power10;
XLowerBound = XLowerBound * power10;
}
और यहां वे विधियां बताई गई हैं जिनके बारे में आप खुद लिख सकते हैं, लेकिन आप मेरा उपयोग भी कर सकते हैं
this.NiceLookingTick = function (tickSize) {
var NiceArray = [1, 2, 2.5, 3, 4, 5, 10];
var tickOrder = Math.floor(Math.log10(tickSize));
var power10 = Math.pow(10, tickOrder);
tickSize = tickSize / power10;
var niceTick;
var minDistance = 10;
var index = 0;
for (var i = 0; i < NiceArray.length; i++) {
var dist = Math.abs(NiceArray[i] - tickSize);
if (dist < minDistance) {
minDistance = dist;
index = i;
}
}
return NiceArray[index] * power10;
}
this.HasZeroTick = function (maxRound, minRound, tickSize) {
if (maxRound * minRound < 0)
{
return true;
}
else if (Math.abs(maxRound) < tickSize || Math.round(minRound) < tickSize) {
return true;
}
else {
return false;
}
}
केवल एक और चीज है जो यहां शामिल नहीं है। यह "अच्छी लग रही सीमा" है। ये निचली सीमाएं हैं जो "अच्छे दिखने वाले टिक्स" में संख्याओं के समान हैं। उदाहरण के लिए, टिक आकार 5 के साथ कम से कम 5 से शुरू होना बेहतर है एक प्लॉट होने की तुलना में 6 पर एक ही टिक आकार के साथ शुरू होता है। लेकिन यह मेरा निकाल दिया मैं इसे आप पर छोड़ दें।
आशा करता हूँ की ये काम करेगा। चीयर्स!