दिलचस्प पोस्ट
कॉलम डेटा को पंक्तियों में विभाजित करने के लिए SQL क्वेरी सी # यूटीएफ -8 से आईएसओ -885 9-1 (लैटिन 1) एच से स्ट्रिंग कन्वर्ट करें जावा में, एनएएन का मतलब क्या है? डीएलएल से std :: ऑब्जेक्ट्स (वेक्टर, मैप, आदि) युक्त वर्गों का निर्यात सी #: एक विरासत घटना में वृद्धि गिट में लेखक और कमेंटेटर के बीच का अंतर? पायथन 3.2 urllib2 आयात करने में असमर्थ (आयातई त्रुटि: urllib2 नामक कोई मॉड्यूल नहीं है) MvcSiteMap ने ब्रेडकंबों को गड़बड़ किए बिना एक मेनू का निर्माण किया मैक से विंडोज तक न्यूलाइन फॉर्मेटिंग परिवर्तित करना 1.0 के एएस के अपडेट के बाद, "विधि आईडी में नहीं है: 65536" परियोजना में त्रुटि अपवादों को संभालने, क्या यह एक अच्छा तरीका है? पीएचजी की जीडीलिब इमेजकोपीरेटमप्लेड का इस्तेमाल करते समय पीएनजी छवि पारदर्शिता को संरक्षित किया जा सकता है? जावास्क्रिप्ट के साथ ऑडियो बजाना? फेसबुक कनेक्ट- $ user_id = $ facebook-> getUser (); हमेशा वापस 0 नोडजेएस बेस 64 इमेज एन्कोडिंग / डिकोडिंग काफी काम नहीं कर रहा है

MATLAB ओओपी धीमा है या क्या मैं कुछ गलत कर रहा हूं?

मैं MATLAB OOP के साथ प्रयोग कर रहा हूं, एक शुरुआत के रूप में मैंने अपने सी ++ के लकड़हारा वर्गों की नकल की है और मैं स्ट्रिंग क्लास में अपने सभी स्ट्रिंग हेल्पर फ़ंक्शन डाल रहा हूं, यह सोच रहा है कि a + b , a == b , a == ba.find( b ) बजाय a.find( b ) strcat( ab ) , strcmp( a, b ) , strfind( a, b ) इत्यादि का पहला तत्व प्राप्त करें।

समस्या: मंदी

मैंने उपरोक्त चीजों को उपयोग में रख दिया और तुरंत एक कठोर मंदी देखा। क्या मैं इसे गलत कर रहा हूं (जो निश्चित रूप से संभव है क्योंकि मुझे मैटलॉग अनुभव सीमित नहीं है), या क्या MATLAB के ओओपी ने बहुत ज्यादा उपरि शुरू किया है?

मेरा परीक्षण केस

यहाँ स्ट्रिंग के लिए मैंने जो सरल परीक्षण किया है, मूल रूप से सिर्फ एक स्ट्रिंग संलग्न करने और संलग्न किए गए भाग को फिर से निकालना है:

 classdef String < handle .... properties stringobj = ''; end function o = plus( o, b ) o.stringobj = [ o.stringobj b ]; end function n = Length( o ) n = length( o.stringobj ); end function o = SetLength( o, n ) o.stringobj = o.stringobj( 1 : n ); end end function atest( a, b ) %plain functions n = length( a ); a = [ ab ]; a = a( 1 : n ); function btest( a, b ) %OOP n = a.Length(); a = a + b; a.SetLength( n ); function RunProfilerLoop( nLoop, fun, varargin ) profile on; for i = 1 : nLoop fun( varargin{ : } ); end profile off; profile report; a = 'test'; aString = String( 'test' ); RunProfilerLoop( 1000, @(x,y)atest(x,y), a, 'appendme' ); RunProfilerLoop( 1000, @(x,y)btest(x,y), aString, 'appendme' ); 

परिणाम

1000 पुनरावृत्तियों के लिए सेकंड में कुल समय:

btest 0.550 (स्ट्रिंग के साथ। लैटिन 0.138, स्ट्रिंग.प्लस 0.065, स्ट्रिंग। लैंगलाइन 0.057)

atest 0.015

लॉगर सिस्टम के लिए परिणाम इसी प्रकार हैं: frpintf( 1, 'test\n' ) क्लास का उपयोग आंतरिक रूप से (ठीक है, यह बहुत अधिक है, मेरे सिस्टम में 1000 कॉलों के लिए 1000 कॉल के लिए frpintf( 1, 'test\n' ) , 7 (!) सेकंड्स के लिए 0.1 सेकंड इसमें तर्क है, लेकिन सी ++ के साथ तुलना करने के लिए: मेरे सिस्टम का ओवरहेड जो std::string( "blah" ) और std::cout आउटपुट साइड std::cout << "blah" ऑर्डर पर बना है 1 मिलीसेकंड का।)

क्या क्लास / पैकेज फ़ंक्शंस को देखकर क्या यह सिर्फ उपरि है?

चूंकि MATLAB का अर्थ है, इसे चलाने के समय फ़ंक्शन / ऑब्जेक्ट की परिभाषा को देखना होगा। इसलिए मैं सोच रहा था कि रास्ते में मौजूद वर्ग या पैकेज फ़ंक्शन बनाम फ़ंक्शंस को देखने में शायद अधिक ऊपरी भाग शामिल है। मैंने यह परीक्षण करने की कोशिश की, और यह सिर्फ अजनबी हो। कक्षाओं / ऑब्जेक्ट्स के प्रभाव से इनकार करने के लिए, मैं किसी फ़ंक्शन को एक फ़ंक्शन को पैकेज में फ़ंक्शन बुलाते हुए कॉल करना पसंद करता हूं:

 function n = atest( x, y ) n = ctest( x, y ); % ctest is in matlab path function n = btest( x, y ) n = util.ctest( x, y ); % ctest is in +util directory, parent directory is in path 

परिणाम, उपरोक्त तरीके से इकट्ठे हुए:

कम से कम 0.004 सेकंड, 0.001 सेकेंड सीटीएसटी में

btest 0.060 सेकंड, 0.014 सेकंड util.ctest में

तो, यह सब ऊपरी भाग है जो कि मैटलैप खर्च के समय से आने वाले ओएपी कार्यान्वयन की परिभाषाओं को देख रहा है, जबकि इस ओवरहेड में उन कार्यों के लिए नहीं है जो सीधे रास्ते में हैं?

Solutions Collecting From Web of "MATLAB ओओपी धीमा है या क्या मैं कुछ गलत कर रहा हूं?"

मैं थोड़ी देर के लिए ओओ मैटलबैग के साथ काम कर रहा हूं, और इसी तरह के प्रदर्शन वाले मुद्दों को देखकर समाप्त हुआ।

संक्षेप में उत्तर है: हां, MATLAB का ओओपी धीमी गति से है मुख्य पद्धति ओओ भाषाओं की तुलना में अधिक महत्वपूर्ण विधि कॉल ओवरहेड है, और आप इसके बारे में बहुत कुछ नहीं कर सकते। कारण का एक हिस्सा हो सकता है कि idiomatic MATLAB विधि कॉल की संख्या को कम करने के लिए "vectorized" कोड का उपयोग करता है, और प्रति कॉल ओवरहेड उच्च प्राथमिकता नहीं है

मैंने विभिन्न प्रकार के फ़ंक्शंस और विधियों के रूप में कुछ भी नहीं "एनओपी" फ़ंक्शन लिखकर प्रदर्शन को बेंचमार्क किया यहां कुछ सामान्य परिणाम दिए गए हैं

 >> कॉल_एनॉप
 कंप्यूटर: पीसीडब्ल्यूआईएन रिलीज: 200 9
 प्रत्येक फ़ंक्शन / पद्धति को 100000 बार कॉल करना
 nop () फ़ंक्शन: 0.02261 सेकंड 0.23 उपयोग कॉल प्रति कॉल
 nop1-5 () फ़ंक्शंस: 0.02182 सेकंड 0.22 प्रति कॉल कॉल
 nop () सबफ़ंक्शन: 0.02244 सेकंड 0.22 प्रति कॉल कॉल
 @ () [] अनाम फ़ंक्शन: 0.08461 सेकंड 0.85 प्रति कॉल कॉल
 एनओपी (ओबीजे) विधि: 0.24664 सेकंड 2.47 प्रति कॉल प्रति कॉल
 nop1-5 (obj) विधियों: 0.23469 सेकंड 2.35 प्रति कॉल कॉल
 nop () निजी फ़ंक्शन: 0.02197 सेकंड 0.22 प्रति कॉल कॉल
 क्लासडेफ एनओपी (ओबीजे): 0.90547 सेकेंड 9.05 प्रति कॉल्स कॉल
 classdef obj.nop (): 1.75522 सेकंड 17.55 प्रति कॉल कॉल
 classdef private_nop (obj): 0.84738 सेकंड 8.47 usec प्रति कॉल
 क्लासडेफ एनओपी (ओबीजे) (एम-फाइल): 0.90560 सेकेंड 9.06 प्रति कॉल्स कॉल
 classdef class.staticnop (): 1.16361 सेकंड 11.64 प्रति कॉल का उपयोग करें
 जावा नॉप (): 2.43035 सेकंड 24.30 प्रति कॉल उपयोग
 जावा static_nop (): 0.87682 सेकंड 8.77 प्रति कॉल usec
 जावा नोप () जावा से: 0.00014 सेक 0.00 usec प्रति कॉल
 एमएक्स मेक्स्नॉप (): 0.1140 9 सेकेंड 1.14 प्रति कॉल्स कॉल
 सी नॉप (): 0.00001 सेकंड 0.00 प्रति कॉल कॉल

R2008b के माध्यम से R2008a पर इसी तरह के परिणाम यह Windows XP x64 32-बिट MATLAB चल रहा है

"जावा एनओपी ()" एक एम-कोड लूप के भीतर से कॉल किया जाने वाला एक जावा विधि है, और इसमें प्रत्येक कॉल के साथ MATLAB-टू-जावा प्रेषण ओवरहेड शामिल है। जावा से "जावा नाप ()" एक ही बात है जो जावा के लिए () लूप में बुलाया जाता है और उस सीमा जुर्माना को नहीं लगाता है। नमक के एक अनाज के साथ जावा और सी समय लें; एक चतुर संकलक कॉल पूरी तरह से दूर अनुकूलित कर सकता है।

पैकेज स्कोपिंग तंत्र नया है, उसी समय क्लासडेफ क्लास के रूप में पेश किया गया है। इसका व्यवहार संबंधित हो सकता है

कुछ अस्थायी निष्कर्ष:

  • तरीकों कार्यों की तुलना में धीमी हैं
  • नई शैली (classdef) विधियों पुराने शैली के तरीकों की तुलना में धीमी हैं
  • नया obj.nop() वाक्यविन्यास nop(obj) obj.nop() सिंटैक्स से धीमी है, यहां तक ​​कि क्लासडेफ़ ऑब्जेक्ट पर उसी विधि के लिए। जावा ऑब्जेक्ट के लिए समान (दिखाया नहीं) यदि आप तेजी से जाना चाहते हैं, तो कॉल nop(obj)
  • विधि कॉल ओवरहेड विंडोज के 64-बिट MATLAB में उच्च (लगभग 2x) है (नहीं दिखाया।)
  • MATLAB विधि प्रेषण कुछ अन्य भाषाओं की तुलना में धीमी है।

कह रही है कि ऐसा क्यों है कि मेरे हिस्से पर अटकलें हैं। MATLAB इंजन के ओ ओ आंतरिक सार्वजनिक नहीं हैं यह एक व्याख्यात्मक बनाम संकलित मुद्दा नहीं है – MATLAB एक जेआईटी है – लेकिन MATLAB का ढीला टाइपिंग और सिंटैक्स रन टाइम पर अधिक काम का मतलब हो सकता है (उदाहरण आप सिंटैक्स से अकेले नहीं बता सकते हैं कि "एफ (एक्स)" एक फ़ंक्शन कॉल या किसी इंडेक्स को एक सरणी में है, यह रन-टाइम पर कार्यस्थान की स्थिति पर निर्भर करता है।) ऐसा इसलिए हो सकता है क्योंकि MATLAB की कक्षा की परिभाषाएं फाइल सिस्टम स्थिति को ऐसे तरीके से जो अन्य कई भाषाओं में नहीं हैं

इसलिए क्या करना है?

इसकी एक मुहावरेदार MATLAB दृष्टिकोण आपकी कक्षा की परिभाषाओं को संरचित करके आपके कोड को "सदिश" करने के लिए है, जैसे कि एक ऑब्जेक्ट इंस्टेंस एक सरणी को लपेटता है; अर्थात्, इसके प्रत्येक फ़ील्ड समानांतर सरणियों (MATLAB प्रलेखन में "प्लानर" संगठन) कहते हैं। ऑब्जेक्ट्स की एक सरणी होने के बजाय प्रत्येक, स्केलर मान वाले फ़ील्ड के साथ, ऑब्जेक्ट्स को परिभाषित करता है जो स्वयं अर्रे होते हैं, और इन पद्धतियों में इनपुट के रूप में एरेज़ लेते हैं, और फ़ील्ड्स और इनपुट पर वेक्टरयुक्त कॉल करते हैं। यह विधि कॉल की संख्या कम कर देता है, उम्मीद है कि प्रेषण ओवरहेड एक बाधा नहीं है

MATLAB में सी ++ या जावा क्लास की नकल करना संभवतः इष्टतम नहीं होगा जावा / सी ++ क्लास आम तौर पर बनाया जाता है ताकि वस्तुओं को सबसे छोटी बिल्डिंग ब्लॉकों, जैसा कि आप कर सकते हैं (जो कि बहुत से विभिन्न वर्गों) हैं, और आप उन्हें सरणी, संग्रह ऑब्जेक्ट, आदि में लिखें, और उन पर लूप के साथ पुनरावृत्त करें। तेजी से MATLAB कक्षाएं बनाने के लिए, उस दृष्टिकोण को अंदर से बाहर कर दें। जिन बड़े वर्गों के फ़ील्ड सरणियाँ हैं, और उन सरणियों पर vectorized तरीकों को कॉल करें

बिंदु आपके कोड को भाषा की शक्तियों को खेलने के लिए व्यवस्थित करना है – सरणी हैंडलिंग, वैक्टरित गणित – और कमजोर स्पॉट्स से बचें।

संपादित करें: चूंकि मूल पोस्ट, आर2010 बी और आर2011 ए बाहर आ गए हैं। समग्र चित्र एक समान है, एमसीओएस कॉल को थोड़ा तेज हो रही है, और जावा और पुरानी शैली पद्धति धीमी हो रही है।

संपादित करें: फ़ंक्शन कॉल के समय की एक अतिरिक्त तालिका के साथ मैं "पथ संवेदनशीलता" पर कुछ नोट्स करता था, जहां फ़ंक्शन टाइम्स को प्रभावित किया गया था कि कैसे मैटलब पथ को कॉन्फ़िगर किया गया था, लेकिन ऐसा लगता है कि मेरे विशेष नेटवर्क सेटअप का विचलन समय। ऊपर दिए गए चार्ट समय के साथ मेरे परीक्षणों के महत्व को दर्शाता है

अद्यतन: R2011b

संपादित करें (2/13/2012): R2011b बाहर है, और प्रदर्शन चित्र इस अद्यतन के लिए पर्याप्त रूप से बदल गया है।

 आर्क: पीसीडब्ल्यूआईएन रिलीज: 2011 बी 
 मशीन: R2011b, Windows XP, 8x कोर i7-2600 @ 3.40 गीगा, 3 जीबी रैम, एनवीआईडीआईए एनवीएस 300
 प्रत्येक ऑपरेशन को 100000 बार करना
 शैली कुल μsec प्रति कॉल
 nop () फ़ंक्शन: 0.01578 0.16
 एनओपी (), 10 एक्स लूप अनलोल: 0.01477 0.15
 एनओपी (), 100x लूप अनारोल करें: 0.01518 0.15
 एनओपी () सबफ़ंक्शनः 0.01559 0.16
 @ () [] अनाम फ़ंक्शन: 0.06400 0.64
 nop (obj) विधि: 0.28482 2.85
 nop () निजी फ़ंक्शन: 0.01505 0.15
 क्लासडेफ एनओपी (ओबीजे): 0.43323 4.33
 क्लासडेफ़ obj.nop (): 0.81087 8.11
 क्लासडीएफ प्राइवेट_एनॉप (ओबीजे): 0.32272 3.23
 क्लासडेफ क्लास.स्टीटिक नॉप (): 0.88959 8. 9 0
 क्लासडेफ स्थिरांक: 1.51890 15.19
 classdef संपत्ति: 0.12992 1.30
 प्राप्तकर्ता के साथ क्लासडेफ संपत्ति: 1.39912 13.99
 + pkg.nop () फ़ंक्शन: 0.87345 8.73
 + pkg.nop () अंदर से + pkg: 0.80501 8.05
 जावा obj.nop (): 1.86378 18.64
 जावा नोप (ओबीजे): 0.22645 2.26
 जावा फवल ('एनओपी', ओबीजे): 0.52544 5.25
 जावा क्लास। स्टैटाइट_एनॉप (): 0.35357 3.54
 Java obj.nop () जावा से: 0.00010 0.00
 एमएक्स मेक्स्नॉप (): 0.0870 9 0.87
 सी नॉप (): 0.00001 0.00
 जे () (बिल्टिन): 0.00251 0.03

मुझे लगता है कि इसका नतीजा यह है कि:

  • एमसीओएस / क्लासडेफ पद्धतियां तेज हैं लागत अब पुराने शैली वर्गों के बराबर है, जब तक कि आप foo(obj) वाक्यविन्यास का उपयोग करते हैं इसलिए विधि की गति अब ज्यादातर मामलों में पुराने शैली वर्गों के साथ छड़ी करने का कारण नहीं है। (यश, मैथ वर्क्स!)
  • नामस्थानों में कार्य करना उन्हें धीमा बनाता है। (R2011b में नया नहीं, मेरे परीक्षण में सिर्फ नए।)

अद्यतन: R2014a

मैंने बेंचमार्किंग कोड का पुनर्निर्माण किया है और इसे R2014a पर चलाया है।

 पीसीडब्ल्यूआईएन 64 पर Matlab R2014a  
 Matlab 8.3.0.532 (R2014a) / जावा 1.7.0_11 पर PCWIN64 विंडोज़ 7 6.1 (eilonwy-win7) 
 मशीन: Core i7-3615QM CPU @ 2.30GHz, 4 जीबी रैम (वीएमवेयर वर्चुअल प्लैटफ़ॉर्म)
 nIters = 100000 

 ऑपरेशन टाइम (μsec)  
 nop () फ़ंक्शन: 0.14 
 एनओपी () उपफ़ंक्शन: 0.14 
 @ () [] अनाम फ़ंक्शन: 0.6 9 
 एनओपी (ओबीजे) विधि: 3.28 
 nop () @ वर्ग पर निजी एफसीएन: 0.14 
 क्लासडेफ एनओपी (ओबीजे): 5.30 
 क्लासडेफ़ obj.nop (): 10.78 
 क्लासडेफ पीिवेट_एनॉप (ओबीजे): 4.88 
 classdef class.static_nop (): 11.81 
 क्लासडेफ निरंतर: 4.18 
 classdef संपत्ति: 1.18 
 ग्रेटर के साथ क्लासडेफ संपत्ति: 19.26 
 + pkg.nop () फ़ंक्शन: 4.03 
 + pkg.nop () अंदर से + pkg: 4.16 
 फवल ('एनओपी'): 2.31 
 फवल (@ एनओपी): 0.22 
 ईवाल ('एनओपी'): 59.46 
 जावा obj.nop (): 26.07 
 जावा नॉप (ओबीजे): 3.72 
 जावा फ़वल ('एनओपी', ओबीजी): 9.25 
 जावा क्लास.स्टेटिकनॉप (): 10.54 
 Java obj.nop () जावा से: 0.01 
 एमएक्स मेक्स्नॉप (): 0.91 
 बिल्टिन जे (): 0.02 
 struct s.foo फ़ील्ड पहुंच: 0.14 
 इस्म्पटी (निरंतर): 0.00 

अद्यतन: R2015b: ऑब्जेक्ट तेजी से मिल गया!

यहां R2015b परिणाम हैं, कृपया श्कड द्वारा प्रदान किया गया है। यह एक बड़ा परिवर्तन है: obj.method() काफी तेज है, और अब obj.method() सिंटैक्स method(obj) obj.method() रूप में तेज़ है, और लीगेसी ओओपी ऑब्जेक्ट्स की तुलना में तेज़ है।

 पीसीडब्ल्यूआईएन 64 पर Matlab R2015b  
 मैटलैब 8.6.0.267246 (आर2015 बी) / जावा 1.7.0_60 पीसीडब्ल्यूआईएन 64 विंडोज़ 8 6.2 (नेनेट-शेक) 
 मशीन: कोर i7-4720 एचक्यू सीपीयू 2.60GHz, 16 जीबी रैम (20378)
 nIters = 100000 

 ऑपरेशन टाइम (μsec)  
 nop () फ़ंक्शन: 0.04 
 एनओपी () उपफ़ंक्शन: 0.08 
 @ () [] अनाम फ़ंक्शन: 1.83 
 एनओपी (ओबीजे) विधि: 3.15 
 nop () @ वर्ग पर निजी एफसीएन: 0.04 
 क्लासडेफ नॉप (ओबीजे): 0.28 
 क्लासडेफ़ obj.nop (): 0.31 
 क्लासडेफ पीिवेट_एनॉप (ओबीजे): 0.34 
 classdef class.static_nop (): 0.05 
 क्लासडेफ निरंतर: 0.25 
 classdef संपत्ति: 0.25 
 गेटटर के साथ क्लासडेफ संपत्ति: 0.64 
 + pkg.nop () फ़ंक्शन: 0.04 
 + pkg.nop () अंदर से + pkg: 0.04 
 फवल ('एनओपी'): 8.26 
 फवल (@ एनओपी): 0.63 
 ईवाल ('एनओपी'): 21.22 
 जावा obj.nop (): 14.15 
 जावा नॉप (ओबीजे): 2.50 
 जावा फवल ('एनओपी', ओजीजे): 10.30 
 जावा क्लास.स्टेटिकनॉप (): 24.48 
 Java obj.nop () जावा से: 0.01 
 एमएक्स मेक्स्नॉप (): 0.33 
 बिल्टिन जे (): 0.15 
 struct s.foo फ़ील्ड पहुंच: 0.25 
 इस्मार्थी (निरंतर): 0.13 

बेंचमार्क के लिए स्रोत कोड

मैंने एमआईटी लाइसेंस के तहत रिलीज किए गए GitHub पर इन मानक के लिए स्रोत कोड डाल दिया है I https://github.com/apjanke/matlab-bench

संभाल वर्ग के सभी संदर्भों को सफाई प्रयोजनों के लिए खुद पर नज़र रखने से एक अतिरिक्त उपरि है

संभाल वर्ग के इस्तेमाल के बिना एक ही प्रयोग की कोशिश करें और देखें कि आपके परिणाम क्या हैं।

ओओ प्रदर्शन में उपयोग किए गए MATLAB संस्करण पर काफी निर्भरता है। मैं सभी संस्करणों पर टिप्पणी नहीं कर सकता, लेकिन अनुभव से पता है कि 2012a 2010 संस्करणों में बहुत सुधार हुआ है। कोई मानक और कोई संख्या मौजूद नहीं है। मेरा कोड, विशेष रूप से संभाल वर्गों का उपयोग कर लिखा गया था और 2012a के तहत लिखा गया था पहले संस्करणों के तहत सभी पर नहीं चलेंगे

वास्तव में आपके कोड में कोई समस्या नहीं है लेकिन यह Matlab के साथ एक समस्या है मुझे लगता है कि यह एक तरह की तरह दिखने के लिए खेल रहा है। क्लास कोड को संकलित करने के लिए यह ओवरहेड से कुछ नहीं है। मैंने साधारण वर्ग बिंदु (एक बार संभाल के रूप में) और अन्य (मूल्य वर्ग के रूप में एक बार) के साथ परीक्षण किया है

  classdef Pointh < handle properties X Y end methods function p = Pointh (x,y) pX = x; pY = y; end function d = dist(p,p1) d = (pX - p1.X)^2 + (pY - p1.Y)^2 ; end end end 

यहाँ परीक्षण है

 %handle points ph = Pointh(1,2); ph1 = Pointh(2,3); %values points p = Pointh(1,2); p1 = Pointh(2,3); % vector points pa1 = [1 2 ]; pa2 = [2 3 ]; %Structur points Ps.X = 1; Ps.Y = 2; ps1.X = 2; ps1.Y = 3; N = 1000000; tic for i =1:N ph.dist(ph1); end t1 = toc tic for i =1:N p.dist(p1); end t2 = toc tic for i =1:N norm(pa1-pa2)^2; end t3 = toc tic for i =1:N (Ps.X-ps1.X)^2+(Ps.Y-ps1.Y)^2; end t4 = toc 

परिणाम t1 =

12.0212% हैंडल

टी 2 =

12.0042% मूल्य

टी 3 =

 0.5489 % vector 

टी 4 =

 0.0707 % structure 

इसलिए कुशल प्रदर्शन के लिए, OOP का उपयोग करने से बचें समूह चर का अच्छा विकल्प है