>>> (float('inf')+0j)*1
(inf+nanj)
কেন? এটি আমার কোডে একটি বাজে বাগের কারণ হয়েছে।
কেন 1
গুণক পরিচয় দিচ্ছে না (inf + 0j)
?
>>> (float('inf')+0j)*1
(inf+nanj)
কেন? এটি আমার কোডে একটি বাজে বাগের কারণ হয়েছে।
কেন 1
গুণক পরিচয় দিচ্ছে না (inf + 0j)
?
উত্তর:
1
প্রথমে একটি জটিল সংখ্যায় রূপান্তরিত করা হয়, 1 + 0j
যা পরে একটি থেকে বিশালাকার inf * 0
গুণ, একটি ফলে nan
।
(inf + 0j) * 1
(inf + 0j) * (1 + 0j)
inf * 1 + inf * 0j + 0j * 1 + 0j * 0j
# ^ this is where it comes from
inf + nan j + 0j - 0
inf + nan j
1
নিক্ষেপ করা হয় 1 + 0j
।
array([inf+0j])*1
এগুলিও মূল্যায়ন করে array([inf+nanj])
। ধরে নিলাম যে আসল গুণটি সি / সি ++ কোডের কোথাও কোথাও ঘটে, এর অর্থ কি তারা _ কমপ্লেক্স বা এসটিডি :: জটিল ব্যবহার না করে সিপিথন আচরণ অনুকরণের জন্য কাস্টম কোড লিখেছিল?
numpy
একটি কেন্দ্রীয় বর্গ ufunc
রয়েছে যা থেকে প্রায় প্রতিটি অপারেটর এবং ফাংশন প্রাপ্ত হয়। ufunc
সম্প্রচার পরিচালনার যত্ন নেয় যে সমস্ত কৌতুকপূর্ণ অ্যাডমিন যাতে অ্যারেগুলির সাথে কাজ করে এমন সুবিধাজনক করে তোলে। একটি নির্দিষ্ট অপারেটর এবং সাধারণ যন্ত্রপাতিগুলির মধ্যে আরও স্পষ্টভাবে শ্রমের বিভাজন হ'ল নির্দিষ্ট অপারেটর প্রতিটি ইনপুট এবং আউটপুট উপাদানগুলির সমন্বয়ের জন্য এটি "অভ্যন্তরীণ লুপগুলি" সেট করে যা এটি পরিচালনা করতে চায়। সাধারণ যন্ত্রপাতি যে কোনও বাহ্যিক লুপের যত্ন নেয় এবং সেরা ম্যাচের অভ্যন্তরীণ লুপটি নির্বাচন করে ...
types
বৈশিষ্ট্যটির মাধ্যমে সরবরাহিত অভ্যন্তরীণ লুপগুলির তালিকাটি অ্যাক্সেস করতে পারি আমরা দেখতে পাচ্ছি যে প্রায় কোনও মিশ্র প্রকার নেই, বিশেষত, জটিলতায় ভাসমান কোনও কিছুই নেই । np.multiply
['??->?', 'bb->b', 'BB->B', 'hh->h', 'HH->H', 'ii->i', 'II->I', 'll->l', 'LL->L', 'qq->q', 'QQ->Q', 'ee->e', 'ff->f', 'dd->d', 'gg->g', 'FF->F', 'DD->D', 'GG->G', 'mq->m', 'qm->m', 'md->m', 'dm->m', 'OO->O']
"efdg"
"FDG"
যান্ত্রিকভাবে, গৃহীত উত্তর অবশ্যই, সঠিক, তবে আমি যুক্তি দেব যে একটি গভীর আনসার দেওয়া যেতে পারে।
প্রথমত, প্রশ্নটি পরিষ্কার করা দরকারী যেহেতু @ পিটারকর্ডস একটি মন্তব্যে করেছেন: "জটিল সংখ্যার জন্য কি এমন একটি গুণ আছে যা ইনফ + 0 জে কাজ করে?" বা অন্য কথায় ওপি জটিল গুণের কম্পিউটার বাস্তবায়নে একটি দুর্বলতা দেখে বা ধারণার সাথে মিলিত কিছু নয়inf+0j
পোলার স্থানাঙ্কগুলি ব্যবহার করে আমরা জটিল গুণটিকে স্কেলিং এবং একটি ঘূর্ণন হিসাবে দেখতে পারি। অসীম "বাহু "কে 0 ডিগ্রি ঘোরানো যেমন একটি দ্বারা গুণনের ক্ষেত্রে আমরা সুনির্দিষ্ট নির্ভুলতার সাথে এর টিপটি রাখার আশা করতে পারি না। সুতরাং প্রকৃতপক্ষে, এমন কিছু আছে যা মূলত ঠিক নয় inf+0j
, যেমন আমরা অনন্তের সাথে সাথেই একটি সীমাবদ্ধ অফসেট অর্থহীন হয়ে যায়।
পটভূমি: "বড় জিনিস" যার চারপাশে এই প্রশ্নটি ঘুরে দেখা যায় সেটি হল সংখ্যাগুলির একটি সিস্টেম বাড়ানোর বিষয়টি (ভাবেন বাস্তব বা জটিল সংখ্যা)। কেউ এটি করতে চাইলে একটি কারণ হ'ল অনন্তের কিছু ধারণা যুক্ত করা, বা যদি কোনও গণিতবিদ হয়ে থাকে তবে "সংযোগীকরণ" করা। অন্যান্য কারণও রয়েছে ( https://en.wikedia.org/wiki/Galois_theory , https://en.wikedia.org/wiki/Non- স্ট্যান্ডার্ড_আ্যানালাইসিস ) তবে আমরা এখানে তাদের আগ্রহী নই।
এই জাতীয় এক্সটেনশানটি সম্পর্কে জটিল কৌশলটি অবশ্যই, আমরা চাই যে এই নতুন সংখ্যাগুলি বিদ্যমান গাণিতিকের সাথে ফিট করে। সহজ উপায় হ'ল অনন্ততায় একটি একক উপাদান যুক্ত করা ( https://en.wikedia.org/wiki/Alexandroff_extension ) এবং এটিকে শূন্য দ্বারা বিভক্ত শূন্য ব্যতীত অন্য কোনও কিছুর সমান করা। এটি বাস্তবের ( https://en.wikedia.org/wiki/Projectively_extended_real_line ) এবং জটিল সংখ্যার ( https://en.wikedia.org/wiki/Riemann_sphere ) জন্য কাজ করে।
যদিও এক বিন্দু সংক্ষিপ্তকরণটি সহজ এবং গাণিতিকভাবে সাবলীল, একাধিক অসম্পূর্ণ সমন্বিত "সমৃদ্ধ" এক্সটেনশানগুলি অনুসন্ধান করা হয়েছে। রিয়েল ভাসমান পয়েন্ট সংখ্যাগুলির জন্য আইইইই 754 মানকটিতে + ইনফ এবং -আইনফ ( https://en.wikedia.org/wiki/Extended_real_number_line ) রয়েছে। প্রাকৃতিক এবং সোজা দেখায় তবে ইতিমধ্যে আমাদেরকে হুপসের মধ্য দিয়ে ঝাঁপিয়ে পড়তে এবং https://en.wikedia.org/wiki/Sign_zero এর মতো স্টাফ আবিষ্কার করতে বাধ্য করে-0
জটিল প্লেনটির এক-ইন-এক্স-এক্সটেনশন সম্পর্কে কী?
কম্পিউটারগুলিতে জটিল সংখ্যা সাধারণত দুটি এফপি রিয়েলকে এক সাথে বাস্তবের জন্য এবং একটিকে কাল্পনিক অংশের জন্য স্টিক করে প্রয়োগ করা হয়। যতক্ষণ না সবকিছু সীমাবদ্ধ ততক্ষণ তা পুরোপুরি ঠিক fine যত তাড়াতাড়ি, অসম্পূর্ণতা হিসাবে বিবেচিত জিনিস জটিল হয়ে ওঠে।
জটিল প্লেনটির একটি প্রাকৃতিক রোটেশনাল প্রতিসাম্য রয়েছে, যা জটিল গাণিতিকের সাথে খুব ভালভাবে জুড়ে যা পুরো প্লেনটিকে ই-ফিজ দিয়ে গুণ করে চারপাশের ফাই রেডিয়ান ঘূর্ণনের সমান 0
।
এখন বিষয়গুলি সহজ রাখতে জটিল এফপি কেবল অন্তর্নিহিত আসল সংখ্যা বাস্তবায়নের এক্সটেনশনগুলি (+/- ইনফ, ন্যান ইত্যাদি) ব্যবহার করে। এই পছন্দটি এটিকে এত প্রাকৃতিক বলে মনে হচ্ছে এটি পছন্দ হিসাবে অনুধাবন করা হয় নি তবে এর অর্থ কী তা বোঝা যাচ্ছে a জটিল প্লেনটির এই সম্প্রসারণের একটি সাধারণ দৃশ্য দেখে মনে হচ্ছে (I = অসীম, চ = সীমাবদ্ধ, 0 = 0)
I IIIIIIIII I
I fffffffff I
I fffffffff I
I fffffffff I
I fffffffff I
I ffff0ffff I
I fffffffff I
I fffffffff I
I fffffffff I
I fffffffff I
I IIIIIIIII I
তবে যেহেতু সত্যিকারের জটিল প্লেনটি জটিল গুণকে সম্মান করে, তাই আরও তথ্যমূলক প্রক্ষেপণ হবে
III
I I
fffff
fffffff
fffffffff
I fffffffff I
I ffff0ffff I
I fffffffff I
fffffffff
fffffff
fffff
I I
III
এই প্রক্ষেপণে আমরা অসম্পূর্ণতার "অসম বন্টন" দেখতে পাই যা কেবল কুৎসিতই নয়, তবে ওপি ধরণের সমস্যার মূলও ভোগ করেছে: বেশিরভাগ অসম্পূর্ণতা (ফর্মগুলির মধ্যে (+/- ইনফ, সীমাবদ্ধ) এবং (সীমাবদ্ধ, + / -inf) চারটি মূল নির্দেশে একসাথে চুপি চুটিয়ে সমস্ত অন্যান্য দিককে কেবল চারটি অসম্পূর্ণতা দ্বারা উপস্থাপন করা হয় (+/- inf, + -inf) এই জ্যামিতিতে জটিল গুণকে বাড়ানো দুঃস্বপ্ন বলে অবাক হওয়া উচিত নয় ।
সি 99 এর আনেক্সেক্স জি এটিকে কীভাবে inf
এবং কীভাবে nan
ইন্টারঅ্যাক্ট করবেন (মূলত inf
ট্রাম্পগুলি nan
) তার নিয়মগুলি বাঁকানো সহ এটি কার্যকর করার জন্য সর্বোত্তম চেষ্টা করে । বাস্তবের বাস্তবতা এবং প্রস্তাবিত নিখুঁত কল্পিত ধরণের জটিলতায় প্রচার না করে ওপির সমস্যাটি পাশাপাশি রয়েছে, তবে জটিল 1 থেকে বাস্তব 1 আচরণ করা আমাকে সমাধান হিসাবে আঘাত করে না। স্পষ্টতই, এনেক্সেক্স দু'টি অসম্পূর্ণতার পণ্যের কী হওয়া উচিত তা সম্পূর্ণরূপে নির্দিষ্ট করে ছাড়িয়ে যান।
অসম্পূর্ণতার আরও ভাল জ্যামিতি বাছাই করে এই সমস্যাগুলি সমাধান করার চেষ্টা করার এবং এটি লোভনীয়। প্রসারিত আসল লাইনের সাথে সাদৃশ্যগুলিতে আমরা প্রতিটি দিকের জন্য একটি করে অসীম যোগ করতে পারি। এই নির্মাণটি ভবিষ্যদ্বাণীপূর্ণ সমতলের মতো তবে বিপরীত দিকগুলি একসাথে একসাথে করে না। ইনফিনিটিগুলি মেরু স্থানাঙ্কগুলিতে প্রতিনিধিত্ব করা হবে ইনফ xe {2 ওমেগা পাই}, পণ্য সংজ্ঞায়িত করা সহজবোধ্য হবে। বিশেষত, ওপির সমস্যাটি বেশ স্বাভাবিকভাবেই সমাধান করা হবে।
তবে এখানেই সুসংবাদটি শেষ হয়। একটি উপায়ে আমাদের একের পর এক স্কোয়ারে ফেলে দেওয়া যেতে পারে --- অযৌক্তিকভাবে নয় --- আমাদের নতুন স্টাইল ইনফিনিটিগুলি তাদের ফাংশনগুলিকে সমর্থন করে যা তাদের আসল বা কল্পিত অংশগুলি বের করে। সংযোজন আরেকটি সমস্যা; দু'টি নন্টিপোডাল ইনফিনটিস যুক্ত করে আমাদের কোণটিকে অপরিজ্ঞাত করতে হবে অর্থাৎ nan
( দুটি আঙ্গুলের কোণের মধ্যে কোণ অবশ্যই থাকা উচিত তবে "আংশিক ন্যান-নেস" উপস্থাপনের কোনও সহজ উপায় নেই)
এই সমস্তের পরিপ্রেক্ষিতে সম্ভবত ভাল পুরাতন এক পয়েন্টের সংক্ষিপ্তকরণটি সবচেয়ে নিরাপদ কাজ। cproj
সমস্ত ইনফিনিটিকে একসাথে ঠেকিয়ে এমন কোনও ফাংশন জারি করার সময় অ্যানেক্স জি এর লেখকরাও একইরকম অনুভব করেছিলেন ।
এখানে আমার সম্পর্কিত বিষয়ে আরও দক্ষ ব্যক্তিদের দ্বারা উত্তর দেওয়া সম্পর্কিত একটি প্রশ্ন question
nan != nan
। আমি বুঝতে পেরেছি যে এই উত্তরটি অর্ধ-রসিক, তবে কেন এটি লিখিতভাবে ওপি'র পক্ষে সহায়ক হওয়া উচিত তা আমি দেখতে ব্যর্থ।
==
(এবং তারা অন্য উত্তরটি মেনে নিয়েছিল), মনে হয় এটি ওপি কীভাবে শিরোনাম প্রকাশ করেছিল তার একটি সমস্যা ছিল। আমি অসামঞ্জস্যতা ঠিক করতে শিরোনামটি বানিয়েছি। (ইচ্ছাকৃতভাবে এই উত্তরের প্রথমার্ধটিকে আক্রমণ করা হচ্ছে কারণ আমি @ কাস্টমাস্টারের সাথে একমত: এটি এই প্রশ্নটি যা জিজ্ঞাসা করছিল তা নয়)।
এটি সিপিথনে জটিল গুণটি কীভাবে প্রয়োগ করা হয় তার একটি বাস্তবায়ন বিশদ। অন্যান্য ভাষার মতো নয় (যেমন সি বা সি ++), সিপিথন কিছুটা সরল পদ্ধতি গ্রহণ করে:
Py_complex
_Py_c_prod(Py_complex a, Py_complex b)
{
Py_complex r;
r.real = a.real*b.real - a.imag*b.imag;
r.imag = a.real*b.imag + a.imag*b.real;
return r;
}
উপরের কোড সহ একটি সমস্যাযুক্ত কেসটি হ'ল:
(0.0+1.0*j)*(inf+inf*j) = (0.0*inf-1*inf)+(0.0*inf+1.0*inf)j
= nan + nan*j
যাইহোক, এক -inf + inf*j
ফলাফল হিসাবে চাই ।
এই ক্ষেত্রে অন্যান্য ভাষাগুলি খুব বেশি এগিয়ে নয়: জটিল সংখ্যার বহুগুণ দীর্ঘকাল ধরে সি স্ট্যান্ডার্ডের অংশ ছিল না, এটি কেবলমাত্র C99 এ পরিশিষ্ট জি হিসাবে অন্তর্ভুক্ত ছিল, যেখানে একটি জটিল গুণটি কীভাবে করা উচিত তা বর্ণনা করে - এবং এটি এতটা সহজ নয় উপরের স্কুলের সূত্র! সি ++ স্ট্যান্ডার্ডটি কীভাবে জটিল গুণকে কাজ করা উচিত তা নির্দিষ্ট করে না, সুতরাং বেশিরভাগ সংকলক বাস্তবায়নগুলি সি-বাস্তবায়নে পিছিয়ে পড়ছে, যা সি 99 কনফর্মিং (জিসিসি, ক্ল্যাং) হতে পারে (এমএসভিসি) হতে পারে।
উপরের "সমস্যাযুক্ত" উদাহরণস্বরূপ, C99- অনুবর্তী বাস্তবায়ন (যা স্কুলের সূত্রের চেয়ে জটিল ) তাদের প্রত্যাশিত ফলাফল দেয় ( সরাসরি দেখুন ):
(0.0+1.0*j)*(inf+inf*j) = -inf + inf*j
এমনকি সি 99 স্ট্যান্ডার্ডের সাথেও, একটি অস্পষ্ট ফলাফল সমস্ত ইনপুটগুলির জন্য সংজ্ঞায়িত করা হয় না এবং এটি সি 99-অনুবর্তী সংস্করণগুলির জন্যও আলাদা হতে পারে।
সি 99 float
তে পদোন্নতি না পাওয়ার আরেকটি পার্শ্ব প্রতিক্রিয়া complex
হ'ল এটির inf+0.0j
সাথে গুণ করা 1.0
বা 1.0+0.0j
বিভিন্ন ফলাফল হতে পারে (এখানে সরাসরি দেখুন):
(inf+0.0j)*1.0 = inf+0.0j
(inf+0.0j)*(1.0+0.0j) = inf-nanj
, কল্পিত অংশ হওয়ার -nan
এবং nan
(CPython জন্য হিসাবে) কারণ সব শান্ত Nans সমতুল্য (দেখুন হয় একটি ভূমিকা এখানে খেলতে না এই ), এমনকি তাদের কিছু নিদর্শন-বিট সেট আছে (এবং এইভাবে যেমন মুদ্রিত "-" দেখুন এই ) এবং কিছু না।যা অন্তত পাল্টা স্বজ্ঞাত।
এটি থেকে আমার মূল কথাটি হ'ল: "সরল" জটিল সংখ্যা গুণ (বা বিভাগ) সম্পর্কে সাধারণ কিছুই নেই এবং ভাষা বা সংকলকগুলির মধ্যে স্যুইচ করার সময় সূক্ষ্ম বাগ / পার্থক্যের জন্য নিজেকে অবশ্যই ব্রেস করা উচিত।
printf
এবং অনুরূপ দ্বিগুণের সাথে কাজ করে তার একটি বাস্তবায়ন বিশদ : "-" প্রিন্ট করা উচিত কিনা তা সিদ্ধান্ত নিতে তারা সাইন-বিটের দিকে তাকান (এটি নান হোক না কেন)। সুতরাং আপনি ঠিক বলেছেন, "নান" এবং "-নান" এর মধ্যে কোনও অর্থপূর্ণ পার্থক্য নেই, শীঘ্রই উত্তরের এই অংশটি ঠিক করুন।
পাইথন থেকে মজার সংজ্ঞা। আমরা একটি কলম এবং কাগজ সঙ্গে এই সমাধানে হয় আমি বলতে হবে যে প্রত্যাশিত ফলাফলের হবে expected: (inf + 0j)
হিসাবে আপনি নির্দিষ্ট কারণ আমরা জানি যে আমরা আদর্শ মানে 1
তাই (float('inf')+0j)*1 =should= ('inf'+0j)
:
তবে আপনি যেমন দেখতে পাচ্ছেন তেমন কিছু নয় ... আমরা যখন এটি চালাই আমরা পাই:
>>> Complex( float('inf') , 0j ) * 1
result: (inf + nanj)
পাইথন এই বুঝতে পারে *1
একটি জটিল সংখ্যা এবং আদর্শ হিসাবে 1
তাই এটি যেমন ব্যাখ্যা করে *(1+0j)
এবং ত্রুটি প্রদর্শিত আমরা কি করতে চেষ্টা inf * 0j = nanj
হিসাবে inf*0
সমাধান করা যাবে না।
আপনি আসলে যা করতে চান (ধরে নেওয়া 1 এর আদর্শ) 1:
মনে রাখবেন যে যদি z = x + iy
সত্যিকারের অংশ x এবং কাল্পনিক অংশ y সহ একটি জটিল সংখ্যা হয় তবে এর জটিল সংঘটিতকে z
সংজ্ঞায়িত করা হয় z* = x − iy
, এবং পরম মান, যাকে বলা হয় norm of z
:
ধরে 1
নেওয়া আমাদের আদর্শ হিসাবে 1
এরকম কিছু করা উচিত:
>>> c_num = complex(float('inf'),0)
>>> value = 1
>>> realPart=(c_num.real)*value
>>> imagPart=(c_num.imag)*value
>>> complex(realPart,imagPart)
result: (inf+0j)
আমি খুব স্বজ্ঞাত জানি না ... তবে কখনও কখনও কোডিং ভাষাগুলি আমাদের প্রতিদিনের ব্যবহারের থেকে আলাদাভাবে সংজ্ঞায়িত হয়।