আপনার গাণিতিক সরঞ্জাম ব্যাগে কি আছে? [বন্ধ]

152

আমরা সকলেই জানি যে ম্যাথমেটিকা ​​দুর্দান্ত, তবে এটিতে প্রায়শই সমালোচনামূলক কার্যকারিতা নেই। আপনি গণিতের সাথে কোন ধরণের বাহ্যিক প্যাকেজ / সরঞ্জাম / সংস্থান ব্যবহার করেন?

আমি এই প্রধান পোস্টটি সম্পাদনা করব (এবং অন্য কাউকেও এটি করার জন্য আমন্ত্রিত করব) বৈজ্ঞানিক গবেষণায় সাধারণ প্রয়োগযোগ্যতার উপর দৃষ্টি নিবদ্ধ করা এবং যা যতটা সম্ভব লোক দরকারী বলে মনে করবে এই সংস্থানগুলি অন্তর্ভুক্ত করার জন্য এই প্রধান পোস্টটি সম্পাদনা করব। যেকোনও অবদান নির্দ্বিধায়, এমনকি ছোট কোড স্নিপেটগুলি (যেমন আমি একটি সময় নীতিমালা জন্য নীচে করেছি)।

এছাড়াও, ম্যাথমেটিকিয়া 7 এবং তার বাইরে আপনি নিজেকে খুঁজে পেয়েছেন বা কোনও কাগজ / সাইট থেকে খনন করেছেন অনাবন্ধিত এবং দরকারী বৈশিষ্ট্যগুলি স্বাগত are

দয়া করে একটি সংক্ষিপ্ত বিবরণ অন্তর্ভুক্ত করুন বা কেন কিছু দুর্দান্ত বা এটি কী সরবরাহ করে তা সম্পর্কে মন্তব্য করুন comment যদি আপনি অনুমোদিত লিঙ্কগুলির সাথে অ্যামাজনে বইগুলিতে লিঙ্ক করেন তবে দয়া করে এটি উল্লেখ করুন, লিঙ্কটির পরে নিজের নাম রেখে।

প্যাকেজ:

  1. LevelSchemeএমন একটি প্যাকেজ যা সুদর্শন প্লট উত্পাদন করার জন্য ম্যাথমেটিকার দক্ষতা ব্যাপকভাবে প্রসারিত করে। আমি অন্য কোনও কিছুর জন্য না হলে এটি ব্যবহার করি তবে ফ্রেম / অক্ষ অক্ষের উপরে অনেক বেশি উন্নত নিয়ন্ত্রণের জন্য। এর সর্বশেষতম সংস্করণটিকে সায়িড্রাও বলা হয় এবং এটি এ বছরের একসময় প্রকাশিত হবে।
  2. ডেভিড পার্কের Presentation Package(50 ডলার - আপডেটের জন্য কোনও মূল্য নেই)
  3. জেরেমি মাইকেলসনের grassmannOpsপ্যাকেজটি গ্রাসম্যান ভেরিয়েবল এবং অপারেটরগুলির সাথে বীজগণিত এবং ক্যালকুলাস করার জন্য সংস্থান সরবরাহ করে যা অপ্রয়োজনীয় পরিবহনের সম্পর্ক রাখে।
  4. GrassmannAlgebraগ্রাসম্যান এবং ক্লিফোর্ড বীজগণিতগুলির সাথে কাজ করার জন্য জন ব্রাউন এর প্যাকেজ এবং বই।
  5. আরআইএসসি (সিম্বলিক কম্পিউটেশন রিসার্চ ইনস্টিটিউট) -এ ডাউনলোডের জন্য গণিতের (এবং অন্যান্য ভাষাগুলি) বিভিন্ন ধরণের প্যাকেজ রয়েছে। বিশেষ করে, নেই Theorema স্বয়ংক্রিয় উপপাদ্য প্রতিপাদন জন্য, এবং সিম্বলিক সঙ্কলন, পার্থক্য সমীকরণ এ ইত্যাদি জন্য প্যাকেজ বৃন্দ আলগোরিদিমজাত সংযুক্তকারিতা গ্রুপের সফ্টওয়্যার পৃষ্ঠা ।

সরঞ্জাম:

  1. MASHড্যানিয়েল রিভসের দুর্দান্ত পার্ল স্ক্রিপ্টটি মূলত ম্যাথমেটিকা ​​ভি 7 এর জন্য স্ক্রিপ্টিং সমর্থন সরবরাহ করে। (এখন ম্যাথমেটিক 8 হিসাবে নির্মিত -scriptবিকল্প হিসাবে।)
  2. একটি alternate Mathematica shellএকটি গনুহ readline ইনপুট দিয়ে (পাইথন ব্যবহার করে, * স্নো শুধুমাত্র)
  3. কলারম্যাথগুলি প্যাকেজ আপনাকে দৃষ্টিভঙ্গিটি কোনও অভিব্যক্তির অংশগুলি নির্বাচন করতে এবং সেগুলি হেরফের করতে দেয়। http://www.dbaileyconsultancy.co.uk/colour_maths/colour_maths.html

সম্পদ:

  1. ওল্ফ্রামের নিজস্ব সংগ্রহশালায় MathSourceবিভিন্ন অ্যাপ্লিকেশনগুলির জন্য সংকীর্ণ নোটবুকগুলি প্রচুর উপকারী। অন্যান্য বিভাগ যেমন পরীক্ষা করে দেখুন

  2. ম্যাথামেটিকাল উইকিবুক ইন ।

বই:

  1. গাণিতিক প্রোগ্রামিং: লিওনিড শিফরিন ( web, pdf) এর একটি অগ্রণী ভূমিকা হ'ল যদি আপনি গাণিতিকের লুপগুলির জন্য আরও কিছু করতে চান তবে অবশ্যই পড়তে হবে । আমরা Leonidএখানে নিজেই প্রশ্নের উত্তর পেয়ে আনন্দিত ।
  2. জেমস এফ। ফাগিন ( অ্যামাজন ) দ্বারা গাণিতিকের সাথে কোয়ান্টাম পদ্ধতিগুলি
  3. স্টিফেন ওল্ফ্রামের ( অ্যামাজন ) রচিত ম্যাথমেটিকা ​​বই ( web)
  4. স্কামের আউটলাইন ( অ্যামাজন )
  5. স্ট্যান ওয়াগন ( অ্যামাজন ) এর অ্যাকশন-এ ম্যাথমেটিকা - পরিষ্কার পৃষ্ঠাগুলির 600 পৃষ্ঠাগুলি এবং গাণিতিক সংস্করণে পৌঁছে যায় Vis. ভিজ্যুয়ালাইজেশন কৌশলগুলি বিশেষত ভাল, আপনি তাদের কয়েকটি লেখকের উপর দেখতে পারেন Demonstrations Page।
  6. রিচার্ড গেলর্ড ( pdf) - র দ্বারা গাণিতিক প্রোগ্রামিং ফান্ডামেন্টাল - ম্যাথমেটেমিয়া প্রোগ্রামিং সম্পর্কে আপনার যা জানা দরকার তার বেশিরভাগের একটি সংক্ষিপ্ত পরিচিতি।
  7. ওআরিলি 2010 832 পৃষ্ঠাগুলি দ্বারা প্রকাশিত সাল ম্যাঙ্গানো দ্বারা গণিতের কুকবুক। - সুপরিচিত ও'রিলি কুকবুক শৈলীতে লেখা: সমস্যা - সমাধান। মধ্যস্থতাকারীদের জন্য।
  8. গাণিতিকের সাথে ডিফারেনশিয়াল সমীকরণ, 3 য় এড। মার্থা এল.এবেল, জেমস পি। ব্রাসেলটন দ্বারা রচিত এলজেভিয়ার 2004 আমস্টারডাম - 893 পৃষ্ঠাগুলি নতুনদের জন্য, একই সাথে ডিইএস এবং ম্যাথামেটিকাকে সমাধান করতে শিখুন।

Undocumented (বা দুর্লভ নথিভুক্ত) বৈশিষ্ট্য:

  1. কীভাবে গণিতের কীবোর্ড শর্টকাটগুলি কাস্টমাইজ করা যায়। দেখুন this question।
  2. গণিতের নিজস্ব ফাংশন দ্বারা ব্যবহৃত নিদর্শন এবং ফাংশন কীভাবে পরিদর্শন করা যায়। দেখাthis answer
  3. গণিতের গ্রাফপ্লটসের জন্য কীভাবে সামঞ্জস্যপূর্ণ আকার অর্জন করবেন? দেখুন this question।
  4. গণিতের সাথে কীভাবে নথি এবং উপস্থাপনা তৈরি করা যায়। দেখুন this question।
resources  wolfram-mathematica 
— ড
সূত্র
2
ম্যাথমেটিকা ​​8 আরও ভাল শেল স্ক্রিপ্ট ইন্টিগ্রেশন সহ বাইরে আছে। wolfram.com/mathematica/new-in-8/mathematica- Shell
— জোশুয়া মার্টেল
2
+1, স্তরশীমের জন্য এটি কিছুটা ধীরে ধীরে। তবে এটিতে টিক চিহ্ন তৈরির জন্য একটি বিচক্ষণ পদ্ধতি রয়েছে এবং গ্রাফিক্সের জন্য জার্নাল যোগ্য লেআউটগুলি তৈরি করা Gridবা এটির মতো আরও কিছু তৈরি করা আরও সহজ ।
— rcollyer
2
এই প্রশ্নের মন্তব্যের আলেক্সি দ্বারা প্রস্তাবিত হিসাবে stackoverflow.com/questions/5152551/... , আমি ম্যাথামেটিকাল জন্য ট্যাগের পুনঃনামকরণ এখানে প্রস্তাবিত: meta.stackexchange.com/questions/81152/... । আপনি যদি সম্মত হন তবে দয়া করে একবার দেখুন এবং উপরে যান। আমি এখানে এটি পোস্ট করছি কারণ এখানে এমএমএ সম্প্রদায়টিতে এই প্রশ্নের অনেক পছন্দ রয়েছে।
— ডাঃ বেলিসেরিয়াস
1
সর্বোপরি, এই প্রশ্নটি স্বাভাবিক কারণে সমস্ত কারণে সম্প্রদায়ের উইকি হওয়া উচিত: এর কোনও সঠিক উত্তর নেই এবং এটি অন্য যে কোনও কিছুর চেয়ে বেশি তালিকার একটি তালিকা। এই প্রশ্নটির সার্থকতায় যারা সুনামের সাথে দুর্দান্তভাবে লাভ করেছেন তাদের সকলের কাছে আমি ক্ষমাপ্রার্থী।
— rcollyer
2
এই প্রশ্নের এই উত্তরগুলি গঠনমূলক, এটি আবার খোলা উচিত।
— এমআর

উত্তর:

29

আমি উল্লেখ করেছি এই আগে, কিন্তু টুল আমি সবচেয়ে দরকারী একজন আবেদন Reapএবং Sowযা নকল / আচরণ প্রসারিত GatherBy:

SelectEquivalents[x_List,f_:Identity, g_:Identity, h_:(#2&)]:=
   Reap[Sow[g[#],{f[#]}]&/@x, _, h][[2]];

এটি আমাকে যে কোনও মানদণ্ড দ্বারা তালিকাগুলি গোষ্ঠীভুক্ত করতে এবং প্রক্রিয়াটিতে তাদের রূপান্তর করতে দেয়। এটি যেভাবে কাজ করে তা হ'ল একটি মাপদণ্ডের ফাংশন ( f) তালিকায় প্রতিটি আইটেম ট্যাগ করে, প্রতিটি আইটেমটি দ্বিতীয় সরবরাহিত ফাংশন ( g) দ্বারা রূপান্তরিত হয় এবং নির্দিষ্ট আউটপুট তৃতীয় ফাংশন ( h) দ্বারা নিয়ন্ত্রিত হয় । ফাংশনটি hদুটি আর্গুমেন্ট গ্রহণ করে: একটি ট্যাগ এবং সংগ্রহ করা আইটেমগুলির একটি তালিকা যা সেই ট্যাগ রয়েছে। আইটেমগুলি তাদের মূল ক্রম বজায় রাখে, তাই আপনি যদি সেট করে থাকেন তবে উদাহরণ হিসাবে যেমন আপনি h = #1&একটি নিরবচ্ছিন্ন হন । তবে, এটি মাধ্যমিক প্রক্রিয়াজাতকরণের জন্য ব্যবহার করা যেতে পারে।UnionReap

এর ইউটিলিটির উদাহরণ হিসাবে, আমি ওয়্যানিয়ের ৯০ এর সাথে কাজ করছি যা স্পষ্টত নির্ভর হ্যামিলটোনিয়ানকে এমন একটি ফাইলে আউটপুট করে যেখানে প্রতিটি লাইন ম্যাট্রিক্সের পৃথক উপাদান, নিম্নরূপ

rx ry rz i j Re[Hij] Im[Hij]

সেই তালিকাটি ম্যাট্রিক্সের সেটগুলিতে পরিণত করতে, আমি সমস্ত সূক্ষ্ম তালিকা জড়ো করেছিলাম যা একই সমন্বয়যুক্ত থাকে, উপাদান তথ্যকে একটি নিয়মে রূপান্তরিত করে (যেমন {i, j} -> পুনরায় [হিজ] + আই ইম [হিজ]), এবং তারপরে সংগৃহীত নিয়মগুলিকে SparseArrayওয়ান লাইনারের সাহায্যে সবগুলিতে পরিণত করে :

SelectEquivalents[hamlst, 
      #[[;; 3]] &, 
      #[[{4, 5}]] -> (Complex @@ #[[6 ;;]]) &, 
      {#1, SparseArray[#2]} &]

সত্যিই, এটি আমার সুইস আর্মি ছুরি এবং এটি জটিল জিনিসগুলিকে খুব সাধারণ করে তোলে। আমার অন্যান্য সরঞ্জামগুলির বেশিরভাগই কিছুটা ডোমেন নির্দিষ্ট, তাই সম্ভবত আমি সেগুলি পোস্ট করব না। যাইহোক, সব সবচেয়ে, যদি না, তাদের রেফারেন্স SelectEquivalents।

সম্পাদনা করুন : এটি সম্পূর্ণরূপে নকল করে GatherByনা যে এটি এক্সপ্রেশনটির একাধিক স্তরকে সহজভাবে গ্রুপ করতে পারে না GatherBy। তবে, Mapআমার যা প্রয়োজন তা বেশিরভাগের জন্য ঠিক কাজ করে।

উদাহরণ : @ ইয়ারোস্লাভ বুলাটোভ একটি স্বনির্ভর উদাহরণ চেয়েছেন। এখানে আমার গবেষণা থেকে একটি যা ব্যাপকভাবে সরল করা হয়েছে। সুতরাং, আসুন আমরা একটি বিমানে পয়েন্ট একটি সেট আছে বলে দিন

In[1] := pts = {{-1, -1, 0}, {-1, 0, 0}, {-1, 1, 0}, {0, -1, 0}, {0, 0, 0}, 
 {0, 1, 0}, {1, -1, 0}, {1, 0, 0}, {1, 1, 0}}

এবং আমরা প্রতিসাম্য ক্রিয়াকলাপগুলির সেট দ্বারা পয়েন্টের সংখ্যা হ্রাস করতে চাই। (কৌতূহলের জন্য, আমরা প্রতিটি পয়েন্টের সামান্য গোষ্ঠী তৈরি করছি this) উদাহরণস্বরূপ, আসুন জেড-অক্ষ সম্পর্কে একটি চার ভাঁজ অক্ষটি ব্যবহার করি

In[2] := rots = RotationTransform[#, {0, 0, 1}] & /@ (Pi/2 Range[0, 3]);

SelectEquivalentsআমরা ব্যবহার করে পয়েন্টগুলি গ্রুপ করতে পারি যা এই ক্রিয়াকলাপগুলির অধীনে একই সেট ইমেজ তৈরি করে, অর্থাত তারা নীচে ব্যবহার করে সমতুল্য

In[3] := SelectEquivalents[ pts, Union[Through[rots[#] ] ]& ] (*<-- Note Union*)
Out[3]:= {{{-1, -1, 0}, {-1, 1, 0}, {1, -1, 0}, {1, 1, 0}},
          {{-1, 0, 0}, {0, -1, 0}, {0, 1, 0}, {1, 0, 0}},
          {{0,0,0}}}

যা সমমানের পয়েন্ট সহ 3 টি উপলিস্ট তৈরি করে। (দ্রষ্টব্য, Unionএখানে একেবারে জরুরী কারণ এটি প্রতিটি পয়েন্ট দ্বারা একই চিত্র তৈরি হয়েছে তা নিশ্চিত করে Orig মূলত, আমি ব্যবহার করেছি Sort, তবে যদি কোনও বিন্দু প্রতিসাম অক্ষের উপরে থাকে তবে এটি অক্ষটির আবর্তনের অধীনে নিজেই একটি অতিরিক্ত চিত্র দেয় is । সুতরাং, Unionএই অতিরিক্ত চিত্রগুলি সরিয়ে দেয় Also GatherByএকই ফলাফলটিও উত্পন্ন করবে)) এই ক্ষেত্রে, পয়েন্টগুলি আমি ইতিমধ্যে ব্যবহার করব এমন ফর্মটিতে রয়েছে তবে প্রতিটি গ্রুপিংয়ের জন্য আমার কেবল একটি প্রতিনিধি পয়েন্ট দরকার এবং আমি একটি গণনা চাই I'd সমতুল্য পয়েন্ট। যেহেতু, আমার প্রতিটি পয়েন্ট রূপান্তর করার দরকার নেই, আমি এটি ব্যবহার করিIdentityদ্বিতীয় অবস্থানে ফাংশন। তৃতীয় ফাংশনের জন্য আমাদের সতর্ক হওয়া দরকার। এটিতে প্রথম যুক্তিটি আবর্তিত হবে এমন পয়েন্টগুলির চিত্রগুলি হবে যা পয়েন্টটির {0,0,0}জন্য চারটি অভিন্ন উপাদানগুলির একটি তালিকা এবং এটি ব্যবহার করে গণনাটি ছুঁড়ে ফেলবে। যাইহোক, দ্বিতীয় যুক্তি হ'ল যে ট্যাগটি রয়েছে এমন সমস্ত উপাদানগুলির একটি তালিকা, সুতরাং এটিতে কেবল এটি থাকবে {0,0,0}। কোডে,

In[4] := SelectEquivalents[pts,  
             Union[Through[rots[#]]]&, #&, {#2[[1]], Length[#2]}& ]
Out[4]:= {{{-1, -1, 0}, 4}, {{-1, 0, 0}, 4}, {{0, 0, 0}, 1}}

দ্রষ্টব্য, এই শেষ পদক্ষেপটি সহজেই সম্পন্ন করা যায় 

In[5] := {#[[1]], Length[#]}& /@ Out[3]

তবে, এটি সর্বনিম্ন কোড সহ কত জটিল রূপান্তর সম্ভব তা দেখতে উপরের এবং এর সম্পূর্ণ কম উদাহরণ সহ এটি সহজ।

— রিভস রকলিয়ার
সূত্র
থ্যাঙ্কসগিভিং ডে 1996-তে আসল ফোর্টরান Day 1996 কোডটি পুনর্গঠন করা হয়েছিল এবং তাই বহু বছর ধরে টার্কি.ফ নামে পরিচিত ...: ডি খুব সুন্দর গ্রাফিক্স বিটিডাব্লু ।
— ফ্যালিকভের
@ বিলেসারিয়াস, আমি ইতিহাস পড়িনি, এটি মজার। আমি সবেমাত্র Wannier90 ব্যবহার শুরু করেছি, তবে এটি Fortranআমি দেখেছি এমন বেশ কয়েকটি সংগঠিত এবং ভাল লিখিত কোড। আমাকে প্রায় ব্যবহারে বিবেচনা করে তোলে Fortran...
— rcollyer
আমি অবাক হয়েছি আপনি যদি নির্বাচনের জন্য নির্বাচিত এক স্বতঃস্ফূর্ত উদাহরণটি যোগ করতে পারেন
— ইয়ারোস্লাভ
@ ইয়ারোস্লাভ বুলাটোভ, অনুরোধ অনুসারে একটি উদাহরণ যুক্ত করেছেন। আমাকে জানতে দা্ও এটা সাহয্য করে কি - না। যদি তা না হয় তবে আমরা কী করব তা আমরা দেখতে পাব।
— rcollyer
আপনি সবচেয়ে আকর্ষণীয় কোড স্নিপেট অবদানের জন্য এই "প্রশ্ন" এর চেকমার্কটি পান get
— টিমো
57

গাণিতিক নোটবুক ইন্টারফেস সম্পর্কে একটি দুর্দান্ত বিষয় হ'ল এটি কেবল ম্যাথমেটিকা ​​নয়, কোনও ভাষায় প্রকাশের মূল্যায়ন করতে পারে । একটি সাধারণ উদাহরণ হিসাবে, একটি নতুন শেল ইনপুট সেল টাইপ তৈরি বিবেচনা করুন যা মূল্যায়নের জন্য অপারেটিং সিস্টেমের শেলটিতে থাকা এক্সপ্রেশনটি পাস করে।

প্রথমে একটি ফাংশনটি সংজ্ঞায়িত করুন যা বাহ্যিক শেলের জন্য একটি পাঠ্য কমান্ডের মূল্যায়ন প্রতিনিধিত্ব করে:

shellEvaluate[cmd_, _] := Import["!"~~cmd, "Text"]

দ্বিতীয় যুক্তিটি কারণগুলির জন্য প্রয়োজন এবং উপেক্ষা করা হবে যা পরে প্রকাশিত হবে। এর পরে, আমরা শেল নামে একটি নতুন স্টাইল তৈরি করতে চাই :

  1. একটি নতুন নোটবুক খুলুন।
  2. মেনু আইটেমটি ফর্ম্যাট / সম্পাদনা স্টাইলশিট নির্বাচন করুন ...
  3. কথোপকথনে, পাশে একটি শৈলীর নাম লিখুন: টাইপ করুন Shell।
  4. নতুন স্টাইলের পাশে ঘর বন্ধনী নির্বাচন করুন।
  5. মেনু আইটেম সেল / প্রদর্শন এক্সপ্রেশন নির্বাচন করুন
  6. নীচে প্রদত্ত পদক্ষেপ 6 পাঠের সাহায্যে কক্ষের এক্সপ্রেশনটি ওভাররাইট করুন ।
  7. আবার, মেনু আইটেম সেল / প্রদর্শন এক্সপ্রেশন নির্বাচন করুন
  8. কথোপকথনটি বন্ধ করুন।

পদক্ষেপ Text পাঠ্য হিসাবে নিম্নলিখিত ঘরটি প্রকাশ করুন :

Cell[StyleData["Shell"],
 CellFrame->{{0, 0}, {0.5, 0.5}},
 CellMargins->{{66, 4}, {0, 8}},
 Evaluatable->True,
 StripStyleOnPaste->True,
 CellEvaluationFunction->shellEvaluate,
 CellFrameLabels->{{None, "Shell"}, {None, None}},
 Hyphenation->False,
 AutoQuoteCharacters->{},
 PasteAutoQuoteCharacters->{},
 LanguageCategory->"Formula",
 ScriptLevel->1,
 MenuSortingValue->1800,
 FontFamily->"Courier"]

এই এক্সপ্রেশনটির বেশিরভাগই অন্তর্নির্মিত প্রোগ্রাম শৈলীতে সরাসরি অনুলিপি করা হয়েছিল । মূল পরিবর্তনগুলি হ'ল এই লাইনগুলি:

 Evaluatable->True,
 CellEvaluationFunction->shellEvaluate,
 CellFrameLabels->{{None, "Shell"}, {None, None}},

Evaluatableঘরের জন্য SHIFT + ENTER কার্যকারিতা সক্ষম করে। মূল্যায়ন CellEvaluationFunctionসেল কন্টেন্ট এবং সামগ্রীর ধরণকে আর্গুমেন্ট হিসাবে চিহ্নিত করবে ( shellEvaluateপরবর্তী যুক্তি উপেক্ষা করে)। CellFrameLabelsএটি কেবল এক নব্বই যে ব্যবহারকারীটি সনাক্ত করুন যে এই ঘরটি অস্বাভাবিক।

এগুলি সব জায়গায় রেখে আমরা এখন শেল এক্সপ্রেশনটি প্রবেশ করে মূল্যায়ন করতে পারি:

  1. উপরের ধাপগুলিতে তৈরি নোটবুকে, একটি খালি ঘর তৈরি করুন এবং সেল বন্ধনী নির্বাচন করুন।
  2. মেনু আইটেম ফর্ম্যাট / স্টাইল / শেল নির্বাচন করুন ।
  3. ঘরে বৈধ অপারেটিং সিস্টেম শেল কমান্ডটি টাইপ করুন (যেমন ইউনিক্সে 'ls' বা উইন্ডোজে 'dir')।
  4. SHIFT + ENTER টিপুন।

কেন্দ্রীয়ভাবে অবস্থিত স্টাইলশিটে এই সংজ্ঞায়িত স্টাইলটি রাখা ভাল। তদ্ব্যতীত, মূল্যায়ন ফাংশনগুলি ডিক্লেয়ারপ্যাকেজ ইন shellEvaluateব্যবহার করে স্টাব হিসাবে সেরা সংজ্ঞায়িত করা হয় init.m। এই উভয় ক্রিয়াকলাপের বিশদটি এই প্রতিক্রিয়ার সুযোগের বাইরে।

এই কার্যকারিতা সহ, কেউ নোটবুক তৈরি করতে পারে যা কোনও আগ্রহের সিনট্যাক্সে ইনপুট এক্সপ্রেশন ধারণ করে। মূল্যায়ন ফাংশনটি খাঁটি গাণিতিকায় লেখা যেতে পারে, বা মূল্যায়নের কোনও বা সমস্ত অংশ কোনও বাহ্যিক সংস্থাকে অর্পণ করতে পারে। সচেতন থাকুন যে অন্যান্য হুক রয়েছে যা সেল মূল্যায়নের সাথে সম্পর্কিত, যেমন CellEpilog, CellPrologএবং CellDynamicExpression।

একটি সাধারণ প্যাটার্নের মধ্যে অন্তর্ভুক্ত কোনও অস্থায়ী ফাইলে ইনপুট এক্সপ্রেশন পাঠ্য লেখা, কোনও ভাষায় ফাইলটি সংকলন করা, প্রোগ্রাম চালানো এবং আউটপুট ঘরে চূড়ান্ত প্রদর্শনের জন্য আউটপুট ক্যাপচারের অন্তর্ভুক্ত। এই ধরণের একটি সম্পূর্ণ সমাধান কার্যকর করার সময় (যেমন ত্রুটি বার্তাগুলি সঠিকভাবে ক্যাপচার করার জন্য) কার্যকর করার জন্য প্রচুর বিশদ রয়েছে তবে এ বিষয়টি অবশ্যই প্রশংসা করতে হবে যে কেবল এটির মতো কাজ করা সম্ভব নয়, তবে ব্যবহারিকও।

একটি ব্যক্তিগত নোটে, এটি এমন বৈশিষ্ট্য যা নোটবুকটি ইন্টারফেসকে আমার প্রোগ্রামিং মহাবিশ্বের কেন্দ্র করে তোলে।

হালনাগাদ

নিম্নলিখিত সহায়ক সহায়ক এই জাতীয় ঘর তৈরি করার জন্য দরকারী:

evaluatableCell[label_String, evaluationFunction_] :=
  ( CellPrint[
      TextCell[
        ""
      , "Program"
      , Evaluatable -> True
      , CellEvaluationFunction -> (evaluationFunction[#]&)
      , CellFrameLabels -> {{None, label}, {None, None}}
      , CellGroupingRules -> "InputGrouping"
      ]
    ]
  ; SelectionMove[EvaluationNotebook[], All, EvaluationCell]
  ; NotebookDelete[]
  ; SelectionMove[EvaluationNotebook[], Next, CellContents]
  )

এটি এভাবে ব্যবহৃত হয়:

shellCell[] := evaluatableCell["shell", Import["!"~~#, "Text"] &]

এখন, যদি shellCell[]মূল্যায়ন করা হয় তবে ইনপুট সেলটি মুছে ফেলা হবে এবং একটি নতুন ইনপুট সেল দিয়ে প্রতিস্থাপন করা হবে যা শেল কমান্ড হিসাবে এর বিষয়বস্তুগুলির মূল্যায়ন করে।

— পুনর্বিবেচনা
সূত্র
3
@WReach +100! আমি যদি এই আগে জানতাম! এটি খুব দরকারী জিনিস, আমার জন্য কমপক্ষে। ভাগ করে নেওয়ার জন্য ধন্যবাদ!
— লিওনিড শিফরিন ২
দেখতে বেশ সুন্দর! CellEvaluationFunctionনিম্ন স্তরের সিনট্যাক্স হ্যাকিংয়ের জন্যও ব্যবহার করা যেতে পারে বলে আমি মনে করি।
— মিঃ উইজার্ড
@ লিওনিড কমপক্ষে ফ্রন্টএন্ডের জন্য, আপনি যে হুকটি CellEvaluationFunctionখুঁজছিলেন তা কি?
— মিঃ উইজার্ড
2
তদ্ব্যতীত: আরও একটি Cellবিকল্প রয়েছে যা ঘরের মূল্যায়ন সম্পর্কিত Evaluator -> "EvaluatorName"। এর অর্থ মূল্যায়ন :: কার্নেল কনফিগারেশন বিকল্প ... ডায়ালগের "EvaluatorName"মাধ্যমে কনফিগার করা যেতে পারে । আমি এখনও জানি না এটি কি প্রোগ্রামেটিমে কো-এটি কনফিগার করা সম্ভব ... এই কৌশলটি একটি নোটবুকে বিভিন্ন ম্যাপে বিভিন্ন ম্যাথ কার্নেল ব্যবহার করার অনুমতি দেয় । এই ম্যাথ কার্নেলগুলি ইনস্টল করা গণিতের বিভিন্ন সংস্করণ হতে পারে । Cell
— আলেক্সি পপকভ
1
@ জাজাবলাক্স এই কৌশলটির আমার নিজের ব্যবহারের উপরে উল্লিখিত চিত্র হিসাবে স্ট্যান্ডিন _ / _ স্টডআউট পদ্ধতি বা এসকিউএল কোয়েরি বা এইচটিটিপি অপারেশন এর মতো স্ব-অন্তর্নিহিত দূরবর্তী অনুরোধ জড়িত । আপনি একটি পাইথন REPL ওয়েব অ্যাপ্লিকেশন (যেমন স্থাপনের চেষ্টা করতে পারে এই ) এবং ব্যবহার করে এটি সাথে আলাপচারিতার Import, অথবা সম্ভবত একটি বহিস্থিত পাইথন প্রক্রিয়া শুরু করার এবং তার স্ট্রিম মাধ্যমে যোগাযোগ (যেমন একটি জাভা ব্যবহার ProcessBuilder )। আমি নিশ্চিত একটি আরও ভাল গাণিতিক উপায় আছে - একটি ভাল SO প্রশ্নের মত শোনা :)
— WReach
36

টড গেইলি (ওল্ফ্রাম রিসার্চ) আমাকে কেবল একটি দুর্দান্ত হ্যাক প্রেরণ করে যা স্বেচ্ছাসেবী কোড সহ অন্তর্নির্মিত ফাংশনগুলিকে "মোড়ানো" করতে দেয়। আমি অনুভব করি যে এই দরকারী সরঞ্জামটি আমাকে ভাগ করে নিতে হবে। নীচে আমার উপর টড এর উত্তর question।

কিছুটা আকর্ষণীয় (?) ইতিহাস: বিল্ট-ইন ফাংশনটির "মোড়ানোর" জন্য হ্যাকের সেই স্টাইলটি ১৯৯৪ সালের দিকে রবি ভিলাগাস এবং আমি উদ্বেগজনকভাবে ফাংশন বার্তার জন্য, ম্যাসেমেটিকা ​​জার্নালের জন্য লিখেছি ত্রুটিহেল্প নামে একটি প্যাকেজে আবিষ্কার করেছিলেন 199 পিছনে তখন তখন থেকেই এটি বহুবার ব্যবহার করা হয়েছে many এটি কিছুটা অন্তঃস্থির কৌশল, তবে আমার মনে হয় যে এটি একটি বিল্ট-ইন ফাংশনটির সংজ্ঞাতে আপনার নিজের কোড ইনজেকশনের স্বীকৃত উপায় হয়ে উঠেছে বলে আমি মনে করি এটি ন্যায়সঙ্গত think এটি সুন্দরভাবে কাজ পেয়ে যায়। আপনি অবশ্যই নিজের পছন্দসই কোনও প্রাইভেট প্রসঙ্গে $ inMsg ভেরিয়েবল রাখতে পারেন।

Unprotect[Message];

Message[args___] := Block[{$inMsg = True, result},
   "some code here";
   result = Message[args];
   "some code here";
   result] /; ! TrueQ[$inMsg]

Protect[Message];
— আলেক্সি পপকভ
সূত্র
@ অ্যালেক্সি এটি বুঝতে আমার অসুবিধা হচ্ছে। এটি কীভাবে কাজ করে তা আপনি ব্যাখ্যা করতে পারেন? কোথাও কোনও অরক্ষিত [বার্তা] থাকা উচিত নয়? এবং এই উদাহরণে অসীম পুনরাবৃত্তি থাকে না? এবং, ! ট্রু কিউ [$ ইনএমএসজি] ব্লক স্কোপের ভিতরে সংজ্ঞায়িত এবং ব্লকের বাইরে অপরিবর্তিত $ inMsg দিয়ে কী বোঝায়?
— সোজয়ের্ড সি ডি ভ্রিজ
9
@ সুজার্ড আমি যা বুঝতে পেরেছি তা থেকে Unprotectসত্যই বাকী ছিল। Block(ডায়নামিক স্কোপিং) এর বিন্দু এবং $inMsgহ'ল অসীম পুনরাবৃত্তি রোধ করতে। কারণ $inMsgবাহিরে অপরিজ্ঞিত (এটি একটি গুরুত্বপূর্ণ প্রয়োজনীয়তা), প্রথমে TrueQমূল্যায়ন করে Falseএবং আমরা ফাংশনের শরীরে প্রবেশ করি। কিন্তু যখন আমাদের দেহের ভিতরে ফাংশন কল আসে তখন শর্তটি মূল্যায়ন করে False(যেহেতু পরিবর্তনশীলটি ব্লক দ্বারা পুনরায় সংজ্ঞায়িত করা হয়)। সুতরাং, ব্যবহারকারীর সংজ্ঞায়িত নিয়ম মেলে না এবং পরিবর্তে বিল্ট-ইন নিয়ম ব্যবহার করা হয়।
— লিওনিড শিফরিন
1
@ লিওনিড ধন্যবাদ, আমি এখন এটি পেয়েছি। খুব চালাক!
— সজোয়ার্ড সি ডি ভ্রিজ 21
1
আমি সবেমাত্র পেয়েছি যে এই কৌশলটি 1999 এর বিকাশকারী সম্মেলনে ওল্ফ্রাম রিসার্চের রবি ভিলেগাস দ্বারা আলোচিত হয়েছিল। দেখুন "ওয়ার্কিং সঙ্গে Unevaluated প্রকাশ" নোটবুক পোস্ট এখানে । এই নোটবুকে রবি ভিলেগাস এই কৌশলটি "বিল্ট-ইন ফাংশনগুলিতে কল আটকে ফেলার জন্য আমার ব্লক ট্রিক" তে সাবটিশনটিতে আলোচনা করেছে discus
— আলেক্সি পপকভ
1
@ মিঃ উইজার্ড এটি করার একমাত্র উপায় নয়। দীর্ঘ সময় ধরে, আমি এমন একটি সংস্করণ ব্যবহার করেছি যেখানে আপনি DownValuesরান-টাইমে পুনরায় সংজ্ঞা দিন , আপনি এই পোস্টটি google.google.com/group/comp.soft-sys.math.mathematica/… দেখতে পারেন , উদাহরণস্বরূপ ( SetDelayedপুনরায় সংজ্ঞা) । তবে আমার পদ্ধতিটি কম মার্জিত, কম শক্তিশালী, আরও ত্রুটি-প্রবণ, এবং পুনরাবৃত্তি থেকে বিরতি কার্যকর করতে অনেক কম তুচ্ছ করে তোলে। সুতরাং, বেশিরভাগ পরিস্থিতিতে, @ অ্যালक्सी দ্বারা বর্ণিত পদ্ধতিটি হাতছাড়া করে।
— লিওনিড শিফরিন
25

এটি একটি সম্পূর্ণ সম্পদ নয়, সুতরাং আমি উত্তর বিভাগে এটি এখানে ফেলে দিচ্ছি, তবে গতির সমস্যাগুলি সনাক্ত করার সময় আমি এটি খুব দরকারী বলে খুঁজে পেয়েছি (যা দুর্ভাগ্যবশত, ম্যাথমেটিকা ​​প্রোগ্রামিং সম্পর্কে যা রয়েছে তার একটি বড় অংশ)।

timeAvg[func_] := Module[
{x = 0, y = 0, timeLimit = 0.1, p, q, iterTimes = Power[10, Range[0, 10]]},
Catch[
 If[(x = First[Timing[(y++; Do[func, {#}]);]]) > timeLimit,
    Throw[{x, y}]
    ] & /@ iterTimes
 ] /. {p_, q_} :> p/iterTimes[[q]]
];
Attributes[timeAvg] = {HoldAll};

ব্যবহার সহজভাবে হয় timeAvg@funcYouWantToTest।

সম্পাদনা করুন: জনাব উইজার্ড যে সঙ্গে দূরে আছে সহজ সংস্করণ প্রদান করেনি Throwএবং Catchএবং বিশ্লেষণ করতে একটু সহজ হল:

SetAttributes[timeAvg, HoldFirst]
timeAvg[func_] := Do[If[# > 0.3, Return[#/5^i]] & @@ 
                     Timing @ Do[func, {5^i}]
                     ,{i, 0, 15}]

সম্পাদনা: এসিএল থেকে একটি সংস্করণ এখানে ( এখানে থেকে নেওয়া ):

timeIt::usage = "timeIt[expr] gives the time taken to execute expr, \
  repeating as many times as necessary to achieve a total time of 1s";

SetAttributes[timeIt, HoldAll]
timeIt[expr_] := Module[{t = Timing[expr;][[1]], tries = 1},
  While[t < 1., tries *= 2; t = Timing[Do[expr, {tries}];][[1]];]; 
  t/tries]
— টিমো
সূত্র
আবার হয়ে গেল এবং আগিন ... আমার নিজের ব্যাগে প্রবেশের সময়। tnx!
— ডাঃ বেলিসারিয়াস
1
এই কোডটির একটি সমস্যা (ভাল, এটি হতে পারে পারফেকশনিস্টের দৃষ্টিভঙ্গি) হ'ল আমরা এমন কিছু ধরতে পারি যা আমরা নিক্ষেপ করি নি এবং এটি একটি ভুল সময়সীমার ফলাফল হিসাবে ব্যাখ্যা করতে পারি। উভয়ই Catchএবং Throwঅনন্য ব্যতিক্রম ট্যাগ সহ ব্যবহার করা উচিত ছিল।
— লিওনিড শিফরিন
2
টিমো, আমি আনন্দিত আপনি আমার প্রতিস্থাপনটি এটি অন্তর্ভুক্ত করার পক্ষে পছন্দ করেন। আমাকেও creditণ দেওয়ার জন্য ধন্যবাদ। আপনি আমার কোডটি পুনরায় ফর্ম্যাট করেছেন সে সম্পর্কে আমি আগ্রহী। আমি আমার নিজের কোডে কোনও বিশেষ নির্দেশিকা অনুসরণ করি না, নিজের পড়া সহজ করে তোলে; আপনার পুনর্নির্মাণের পিছনে কি কোনও স্কুল আছে, বা এটি কেবল পছন্দ? গাণিতিক যেভাবে ইনপুটটি প্রত্যাখ্যান করে সে কারণে কোডের সুনির্দিষ্ট উত্সাহ দেয় না, তবে এখানে কোড পোস্ট করা আমাকে এ সম্পর্কে চিন্তাভাবনা শুরু করে দিচ্ছে। বিটিডাব্লু, আমি মনে করি আপনার অর্থ " Throwএবং Catch" এর চেয়ে " Reapএবং Sow"।
— মিঃ উইজার্ড 26'11
1
@ সিমন, মিঃ উইজার্ড, আমি এই পদ্ধতিটি বিভিন্ন সময়ে বিভিন্ন ধরণের ছোট ছোট ফাংশনগুলিতে ব্যবহার করি যা অনেক সময় বলা হয়ে থাকে be অগত্যা একটি লুপ কাঠামোতে নয় তবে অবশ্যই এমএমএ অনুকূল করে দেয় এমন কাঠামোর মধ্যে। এই প্রসঙ্গে একটি লুপের কার্যকারিতা নির্ধারণের সময়টি অর্থবোধ করে এবং কার্য সম্পাদনটি বাস্তব জীবনের প্রয়োগের কাছাকাছি থাকবে। বৃহত জটিল ফাংশনগুলির সময় নির্ধারণের জন্য (এমনকি পুরো প্রাথমিক কোষগুলি এমনকি) সিমনের পদ্ধতিটি আরও ভাল ফলাফল দেবে। সব মিলিয়ে, আমি আপেক্ষিক মানগুলিতে আরও আগ্রহী এবং উভয় পদ্ধতিই সেখানে কাজ করা উচিত।
— টিমো
3
এটি করার দরকার আছে RepeatedTiming।
— মাস্টারেক্সিলো
20

Internal`InheritedBlock

অফিসিয়াল নিউজ গ্রুপে ড্যানিয়েল লিচতব্লাউয়ের এই বার্তাInternal`InheritedBlock থেকে আমি সম্প্রতি যেমন দরকারী কার্যকারিতাটির অস্তিত্ব শিখেছি ।

যেমনটি আমি বুঝতে পেরেছি, সুযোগের বাইরে Internal`InheritedBlockআউটবাউন্ড ফাংশনটির একটি অনুলিপি পাস করার অনুমতি দেয় Block:

In[1]:= Internal`InheritedBlock[{Message},
Print[Attributes[Message]];
Unprotect[Message];
Message[x___]:=Print[{{x},Stack[]}];
Sin[1,1]
]
Sin[1,1]
During evaluation of In[1]:= {HoldFirst,Protected}
During evaluation of In[1]:= {{Sin::argx,Sin,2},{Internal`InheritedBlock,CompoundExpression,Sin,Print,List}}
Out[1]= Sin[1,1]
During evaluation of In[1]:= Sin::argx: Sin called with 2 arguments; 1 argument is expected. >>
Out[2]= Sin[1,1]

আমি মনে করি যে অস্থায়ীভাবে বিল্ট-ইন ফাংশনগুলি সংশোধন করা দরকার তাদের জন্য এই ফাংশনটি খুব কার্যকর হতে পারে!

ব্লকের সাথে তুলনা

আসুন আমরা কিছু ফাংশন সংজ্ঞায়িত করি:

a := Print[b]

এখন আমরা এই ফাংশনটির একটি অনুলিপি Blockসুযোগের মধ্যে দিয়ে দিতে চাই । নিষ্পাপ পরীক্ষা আমরা যা চাই তা দেয় না:

In[2]:= Block[{a = a}, OwnValues[a]]

During evaluation of In[9]:= b

Out[2]= {HoldPattern[a] :> Null}

প্রথম আর্গুমেন্টে এখন বিলম্বিত সংজ্ঞাটি ব্যবহার করার চেষ্টা করা হচ্ছে Block(এটিও একটি অনিবন্ধিত বৈশিষ্ট্য):

In[3]:= Block[{a := a}, OwnValues[a]]
Block[{a := a}, a]

Out[3]= {HoldPattern[a] :> a}

During evaluation of In[3]:= b

আমরা দেখতে পাই যে aএক্ষেত্রে কাজ করে তবে আমরা সুযোগের মূল aভিতরে একটি অনুলিপি পাইনি Block।

এখন আমাদের চেষ্টা করুন Internal`InheritedBlock:

In[5]:= Internal`InheritedBlock[{a}, OwnValues[a]]

Out[5]= {HoldPattern[a] :> Print[b]}

সুযোগের aঅভ্যন্তরের জন্য Blockআমরা মূল সংজ্ঞাটির একটি অনুলিপি পেয়েছি এবং এটির জন্য বিশ্বব্যাপী সংজ্ঞা প্রভাবিত না করে আমরা এটি যেভাবে চাই তা পরিবর্তন করতে পারি a!

— আলেক্সি পপকভ
সূত্র
+1 খুব সহজ! ব্যাগের আরও একটি সরঞ্জাম এবং আপনার জন্য 10 টি পয়েন্টের সুবিধার্থে সম্পাদনা করুন।
— মিঃ উইজার্ড
আমার কাছে এটি প্রথম বা দেরিতে বা না এবং সম্পূর্ণ মূল্যায়নের বৈকল্পিক হিসাবে উপস্থিত হয়।
— ব্যবহারকারীর 2432923
19

গাণিতিক একটি তীক্ষ্ণ সরঞ্জাম, তবে এটি আপনাকে কিছুটা টাইপযুক্ত আচরণ এবং ক্রিপ্টিক ডায়াগনস্টিক বার্তাগুলির তুষারপাতের সাহায্যে কাটাতে পারে । এটির সাথে মোকাবিলা করার একটি উপায় হ'ল এই প্রতিমাটির অনুসরণ করে কার্যগুলি সংজ্ঞায়িত করা:

ClearAll@zot
SetAttributes[zot, ...]
zot[a_] := ...
zot[b_ /; ...] := ...
zot[___] := (Message[zot::invalidArguments]; Abort[])

এটি অনেকটা বয়লারপ্লেট, যা আমি প্রায়শই এড়াতে প্ররোচিত হই। বিশেষত প্রোটোটাইপিংয়ের সময়, যা ম্যাথমেটেমায় অনেক ঘটে। সুতরাং, আমি একটি ম্যাক্রো নামক ব্যবহার করি defineযা আমাকে শৃঙ্খলাবদ্ধ থাকতে দেয়, অনেক কম বয়লারপ্লেট সহ।

এর একটি প্রাথমিক ব্যবহার defineএরকম:

define[
  fact[0] = 1
; fact[n_ /; n > 0] := n * fact[n-1]
]

fact[5]

120

এটি প্রথমে দেখতে খুব বেশি লাগে না, তবে কিছু গোপন সুবিধা রয়েছে। প্রথম পরিষেবা যা defineসরবরাহ করে তা হ'ল এটি ClearAllসংজ্ঞায়িত হওয়া প্রতীকটিতে স্বয়ংক্রিয়ভাবে প্রযোজ্য । এটি নিশ্চিত করে যে কোনও বাকী সংজ্ঞা নেই - কোনও ক্রিয়াকলাপের প্রাথমিক বিকাশের সময় একটি সাধারণ ঘটনা।

দ্বিতীয় পরিষেবাটি হ'ল ফাংশনটি সংজ্ঞায়িত করা হচ্ছে স্বয়ংক্রিয়ভাবে "বন্ধ"। এর অর্থ এই যে ফাংশনটি একটি বার্তা জারি করবে এবং যদি কোনও যুক্তির তালিকার সাথে যুক্ত হয় তবে এটি কোনও সংজ্ঞায়নের সাথে মিলে না যায়:

fact[-1]

define::badargs: There is no definition for 'fact' applicable to fact[-1].
$Aborted

এটি এর প্রাথমিক মান define, যা খুব সাধারণ শ্রেণীর ত্রুটি ধরে।

অন্য সুবিধাটি সংজ্ঞায়িত হচ্ছে ফাংশনটিতে বৈশিষ্ট্যগুলি নির্দিষ্ট করার একটি সংক্ষিপ্ত উপায়। আসুন ফাংশনটি করা যাক Listable:

define[
  fact[0] = 1
; fact[n_ /; n > 0] := n * fact[n-1]
, Listable
]

fact[{3, 5, 8}]

{6, 120, 40320}

সমস্ত সাধারণ বৈশিষ্ট্য defineছাড়াও , ডাকা অতিরিক্ত বৈশিষ্ট্য গ্রহণ করে Open। এটি defineফাংশনে ক্যাচ-সমস্ত ত্রুটি সংজ্ঞা যুক্ত করতে বাধা দেয় :

define[
  successor[x_ /; x > 0] := x + 1
, Open
]

successor /@ {1, "hi"}

{2, successor["hi"]}

একাধিক বৈশিষ্ট্য একটি ফাংশনের জন্য সংজ্ঞায়িত করা যেতে পারে:

define[
  flatHold[x___] := Hold[x]
, {Flat, HoldAll}
]

flatHold[flatHold[1+1, flatHold[2+3]], 4+5]

Hold[1 + 1, 2 + 3, 4 + 5]

আরও অগ্রগতি ব্যতীত, এখানে সংজ্ঞা define:

ClearAll@define
SetAttributes[define, HoldAll]
define[body_, attribute_Symbol] := define[body, {attribute}]
define[body:(_Set|_SetDelayed), attributes_List:{}] := define[CompoundExpression[body], attributes]
define[body:CompoundExpression[((Set|SetDelayed)[name_Symbol[___], _])..], attributes_List:{}] :=
  ( ClearAll@name
  ; SetAttributes[name, DeleteCases[attributes, Open]]
  ; If[!MemberQ[attributes, Open]
    , def:name[___] := (Message[define::badargs, name, Defer@def]; Abort[])
    ]
  ; body
  ;
  )
def:define[___] := (Message[define::malformed, Defer@def]; Abort[])

define::badargs = "There is no definition for '``' applicable to ``.";
define::malformed = "Malformed definition: ``";

প্রদর্শিত বাস্তবায়ন আপ-ভ্যালু বা কার্য়িংকে সমর্থন করে না বা সাধারণ ফাংশন সংজ্ঞার চেয়ে সাধারণ কোনও নিদর্শনকে সমর্থন করে না। এটি অবশ্য কার্যকর রয়েছে।

— পুনর্বিবেচনা
সূত্র
2
+1 - এটি সত্যই দরকারী জিনিস। আমি অনুরূপ সরঞ্জাম ব্যবহার করা হয়েছে। ম্যাক্রোস (পাশাপাশি অন্তঃসংশোধন এবং অন্যান্য মেটা-প্রোগ্রামিং কৌশলগুলি) খুব শক্তিশালী হতে পারে তবে সাধারণত ম্যাথমেটিকা ​​সম্প্রদায়ের মধ্যে এটি কম-বেশি প্রশংসিত বলে মনে হচ্ছে, বা কমপক্ষে এটি এ পর্যন্ত আমার ছাপ ছিল।
— লিওনিড শিফরিন
আমি সেরকম কিছু সংজ্ঞায়িত করেছি। একাধিক সংজ্ঞা করার জন্য কম্পাউন্ডএক্সপ্রেস সহায়তার জন্য +1, বাতিল করুন [] (আরও বেশি বার্তাগুলির চেয়ে ভাল বলে মনে হচ্ছে) এবং ওপেন (যেমন কনস্ট্রাক্টরের জন্য দুর্দান্ত)।
— মাস্টারেক্সিলো
16

একটি খালি নোটবুক খোলা ছাড়াই শুরু করুন

ফাঁকা নোটবুক খোলা রেখে ম্যাথামেটিকার শুরু করে আমি বিরক্ত হয়েছিলাম। আমি এই নোটবুকটি কোনও স্ক্রিপ্টের সাহায্যে বন্ধ করতে পারতাম তবে এটি সংক্ষেপে খোলা থাকবে। আমার হ্যাকটি এমন একটি ফাইল তৈরি করতে হবে Invisible.nb:

Notebook[{},Visible->False]

এবং এটি আমার সাথে যুক্ত করুন Kernel\init.m:

If[Length[Notebooks["Invisible*"]] > 0, 
  NotebookClose[Notebooks["Invisible*"][[1]]]
]

SetOptions[$FrontEnd,
  Options[$FrontEnd, NotebooksMenu] /. 
    HoldPattern["Invisible.nb" -> {__}] :> Sequence[]
]

আমি এখন খোলার মাধ্যমে ম্যাথমেটিকাকে শুরু করি Invisible.nb

আরও ভাল উপায় থাকতে পারে, তবে এটি আমার ভাল উপকার করেছে।

কাস্টমাইজড FoldএবংFoldList

Fold[f, x] সমান করা হয় Fold[f, First@x, Rest@x]

প্রসঙ্গত, আমি বিশ্বাস করি এটি ম্যাথমেটিকার ভবিষ্যতের সংস্করণে যেতে পারে।

আশ্চর্য! এটি বর্তমানে বাস্তবায়নবিহীন হলেও এটি কার্যকর করা হয়েছে। আমাকে জানানো হয়েছে যে এটি অলিভার রুয়েবেনকোনিগ দ্বারা ২০১১ সালে বাস্তবায়ন করা হয়েছিল, সম্ভবত আমি এই পোস্ট করার খুব বেশি পরে না। অলিভার রুয়েবেনকোনিগকে ধন্যবাদ!

Unprotect[Fold, FoldList]

Fold[f_, h_[a_, b__]] := Fold[f, Unevaluated @ a, h @ b]
FoldList[f_, h_[a_, b__]] := FoldList[f, Unevaluated @ a, h @ b]

(* Faysal's recommendation to modify SyntaxInformation *)
SyntaxInformation[Fold]     = {"ArgumentsPattern" -> {_, _, _.}};
SyntaxInformation[FoldList] = {"ArgumentsPattern" -> {_, _., {__}}};

Protect[Fold, FoldList]

এটি অনুমোদনের জন্য আপডেট হয়েছে:

SetAttributes[f, HoldAll]
Fold[f, Hold[1 + 1, 2/2, 3^3]]
f[f[1 + 1, 2/2], 3^3]

"গতিশীল পার্টিশন"

এই ফাংশনটির নতুন সংস্করণের জন্য ম্যাথমেটিকা.এসই পোস্ট # 7512 দেখুন ।

দৈর্ঘ্যের ক্রম অনুসারে প্রায়শই আমি একটি তালিকা বিভাজন করতে চাই।

সিউডো কোড উদাহরণ:

partition[{1,2,3,4,5,6}, {2,3,1}]

আউটপুট: {{1,2}, {3,4,5}, {6}}

আমি এটি নিয়ে এসেছি:

dynP[l_, p_] := 
 MapThread[l[[# ;; #2]] &, {{0} ~Join~ Most@# + 1, #} &@Accumulate@p]

যা আমি এর পরে যুক্তি পরীক্ষার সহ এটি দিয়ে শেষ করেছি:

dynamicPartition[l_List, p : {_Integer?NonNegative ..}] :=
  dynP[l, p] /; Length@l >= Tr@p

dynamicPartition[l_List, p : {_Integer?NonNegative ..}, All] :=
  dynP[l, p] ~Append~ Drop[l, Tr@p] /; Length@l >= Tr@p

dynamicPartition[l_List, p : {_Integer?NonNegative ..}, n__ | {n__}] :=
  dynP[l, p] ~Join~ Partition[l ~Drop~ Tr@p, n] /; Length@l >= Tr@p

তৃতীয় যুক্তি বিভাজনের স্পেসিফিকেশনের বাইরে উপাদানগুলির কী হবে তা নিয়ন্ত্রণ করে।

জাজাবলসের ম্যাথমেটিক ট্রিক্স

আমি সবচেয়ে ঘন ঘন ব্যবহার করি তা হ'ল ট্যাবুলার ডেটা প্যালেট আটকান

CreatePalette@
 Column@{Button["TSV", 
    Module[{data, strip}, 
     data = NotebookGet[ClipboardNotebook[]][[1, 1, 1]];
     strip[s_String] := 
      StringReplace[s, RegularExpression["^\\s*(.*?)\\s*$"] -> "$1"];
     strip[e_] := e;
     If[Head[data] === String, 
      NotebookWrite[InputNotebook[], 
       ToBoxes@Map[strip, ImportString[data, "TSV"], {2}]]]]], 
   Button["CSV", 
    Module[{data, strip}, 
     data = NotebookGet[ClipboardNotebook[]][[1, 1, 1]];
     strip[s_String] := 
      StringReplace[s, RegularExpression["^\\s*(.*?)\\s*$"] -> "$1"];
     strip[e_] := e;
     If[Head[data] === String, 
      NotebookWrite[InputNotebook[], 
       ToBoxes@Map[strip, ImportString[data, "CSV"], {2}]]]]], 
   Button["Table", 
    Module[{data}, data = NotebookGet[ClipboardNotebook[]][[1, 1, 1]];
     If[Head[data] === String, 
      NotebookWrite[InputNotebook[], 
       ToBoxes@ImportString[data, "Table"]]]]]}

এর মধ্যে থেকে বাহ্যিক ডেটা পরিবর্তন করুন Compile

সম্প্রতি ড্যানিয়েল লিচতব্লাউ এই পদ্ধতিটি দেখিয়েছিলাম যা আমি এর আগে কখনও দেখিনি। আমার মতে এটি এর ইউটিলিটি উল্লেখযোগ্যভাবে প্রসারিত করেCompile

ll = {2., 3., 4.};
c = Compile[{{x}, {y}}, ll[[1]] = x; y];

c[4.5, 5.6]

ll

(* Out[1] = 5.6  *)

(* Out[2] = {4.5, 3., 4.}  *)
— মিঃ উইজার্ড
সূত্র
3
+1 একটি ভাল সংগ্রহ! বাহ্যিক পরিবর্তনগুলি অভ্যন্তরীণ থেকে Compile- আমার সম্পূর্ণ পোস্টটি সম্পর্কে: এখানে stackoverflow.com/questions/5246330/… , একটি তুচ্ছ তাত্পর্যপূর্ণ বিন্যাসে এই সম্ভাবনাটি প্রদর্শন করা ছিল (ইতিমধ্যে পোস্ট করা প্রশ্নের সমস্যার একটি সংক্ষিপ্ত এবং দ্রুত সমাধান ছিল) । আইএমও, এখানে সবচেয়ে বড় জয়টি হ'ল পাস বাই রেফারেন্স অনুকরণ করার ক্ষমতা এবং বৃহত্তর সংকলিত ফাংশনগুলিকে আরও ম্যানেজযোগ্য এবং পুনরায় ব্যবহারযোগ্য অংশগুলিতে ভাঙ্গার ক্ষমতা।
— লিওনিড শিফরিন
1
আপনি নিজের নতুন সংজ্ঞায় ফোল্ড এবং ফোল্ডলিস্টের বাক্য গঠন তথ্যও সামঞ্জস্য করতে পারেন: সিনট্যাক্স ইনফরমেশন [ফোল্ড] = {"আরগমেন্টস প্যাটার্ন" -> {_ ,। , _}}; সিনট্যাক্স ইনফরমেশন [ফোল্ডলিস্ট] = {"আরগমেন্টস প্যাটার্ন" -> {_, _।, {_ }}};
— ফায়সৌ
14

সাধারণ পিডিএফ / ইএমএফ রফতানি সমস্যা এবং সমাধান

1) এটি সম্পূর্ণ অপ্রত্যাশিত এবং অননুমোদিত, তবে গাণিতিক পর্দায় নোটবুকগুলি প্রদর্শনের জন্য ব্যবহৃত স্টাইল সংজ্ঞাগুলির একটি সেট ব্যবহার করে পিডিএফ এবং ইপিএস ফর্ম্যাটে গ্রাফিকগুলি রফতানি এবং সংরক্ষণ করে। ডিফল্টরূপে নোটবুকগুলি স্ক্রিনে "ওয়ার্কিং" শৈলীর পরিবেশে প্রদর্শিত হয় (যা ScreenStyleEvironmentবৈশ্বিক $FrontEndবিকল্পের জন্য ডিফল্ট মান ) তবে "Printout"শৈলী পরিবেশে মুদ্রিত হয় (যা PrintingStyleEnvironmentবৈশ্বিক $FrontEndবিকল্পের জন্য ডিফল্ট মান )। যখন একজন রাস্টার ফর্ম্যাটগুলিতে যেমন জিআইএফ এবং পিএনজি বা ইএমএফ ফর্ম্যাটে গ্রাফিক্স রফতানি করে তবে ম্যাথমেটিকা গ্রাফিক্স উত্সাহিত করে যা দেখতে নোটবুকের অভ্যন্তরের মতো দেখতে লাগে। মনে হয়"Working"এক্ষেত্রে রেন্ডারিংয়ের জন্য শৈলীর পরিবেশ ব্যবহৃত হয়। আপনি যখন পিডিএফ বা ইপিএস ফর্ম্যাটে কোনও রফতানি / সেভ করবেন তখন এমনটি হয় না! এই ক্ষেত্রে "Printout"শৈলীর পরিবেশ ডিফল্টরূপে ব্যবহৃত হয় যা "কার্যকরী" শৈলীর পরিবেশের থেকে খুব গভীরভাবে পৃথক হয়। প্রথম সব, শৈলী পরিবেশ সেট 80% । দ্বিতীয়ত, এটি বিভিন্ন শৈলীর ফন্ট আকারের জন্য নিজস্ব মানগুলি ব্যবহার করে এবং এর ফলে মূল অন-স্ক্রিন উপস্থাপনার তুলনায় জেনারেটেড পিডিএফ ফাইলে অসংলগ্ন ফন্টের আকারের পরিবর্তন ঘটে। পরেরটিকে ফন্টসাইজ ওঠানামা বলা যেতে পারে যা খুব বিরক্তিকর। তবে আনন্দের সাথে বৈশ্বিক বিকল্পটি "ওয়ার্কিং" এ সেট করে এড়ানো যেতে পারে :"Printout"MagnificationPrintingStyleEnvironment$FrontEnd

SetOptions[$FrontEnd, PrintingStyleEnvironment -> "Working"]

2) EMF ফর্ম্যাটে রপ্তানি সঙ্গে সাধারণ সমস্যা হল প্রোগ্রাম অধিকাংশ (না শুধুমাত্র হয় ম্যাথামেটিকাল ) একটি ফাইল ডিফল্ট মাপ দেখে চমৎকার কিন্তু অরুপ যখন আপনি এটা জুম হয়ে উৎপন্ন। কারণ metafiles পর্দার রেজল্যুশন বিশ্বস্ততা এ নমুনা হিসেবে পাঠানো হয় । উত্পাদিত ইএমএফ ফাইলের মানটি Magnifyমূল গ্রাফিকাল অবজেক্টটি আইএন দিয়ে বাড়ানো যেতে পারে যাতে মূল গ্রাফিক্সের নমুনার নিখুঁততা আরও অনেক স্পষ্ট হয়ে যায়। দুটি ফাইলের তুলনা করুন:

graphics1 = 
  First@ImportString[
    ExportString[Style["a", FontFamily -> "Times"], "PDF"], "PDF"];
graphics2 = Magnify[graphics1, 10];
Export["C:\\test1.emf", graphics1]
Export["C:\\test2.emf", graphics2]

আপনি যদি মাইক্রোসফ্ট ওয়ার্ডে এই ফাইলগুলি sertোকান এবং এগুলিকে জুম করেন তবে আপনি দেখতে পাবেন যে প্রথম "এ" এটির উপর একটি সিটি টুথ রেখেছিল যখন দ্বিতীয়টি ( ম্যাথমেটিকিয়া 6 দিয়ে পরীক্ষা করা হয়নি )।

এর মাধ্যমে আরেকটি উপায় ক্রিস দেগেনImageResolution পরামর্শ দিয়েছিলেন (এই বিকল্পটি কমপক্ষে ম্যাথমেটিক 8 থেকে শুরু করে ):

Export["C:\\test1.emf", graphics1]
Export["C:\\test2.emf", graphics1, ImageResolution -> 300]

3) সালে ম্যাথামেটিকাল আমরা তিনটি উপায়ে মেটাফাইল মধ্যে গ্রাফিক্স রূপান্তর করতে হবে: মাধ্যমে Exportকরতে "EMF"(অতিমাত্রায় বাঞ্ছনীয় উপায়: সম্ভাব্য সর্বোচ্চ মানের সঙ্গে মেটাফাইল) উৎপন্ন মাধ্যমে Save selection As...মেনু আইটেম ( অনেক ক্ষুদ্রতর উত্পাদন সুনির্দিষ্ট চিত্রে , প্রস্তাবিত নয়) এবং মাধ্যমে Edit ► Copy As ► Metafileমেনু আইটেম ( আমি দৃঢ়ভাবে সুপারিশ এই পথের বিপরীতে )।

— আলেক্সি পপকভ
সূত্র
13

জনপ্রিয় চাহিদা অনুসারে, এসও এপিআই ব্যবহার করে শীর্ষ-দশ এসও উত্তরদাতাদের প্লট ( টিকা ব্যতীত ) উত্পন্ন করার কোড ।

এখানে চিত্র বর্ণনা লিখুন

getRepChanges[userID_Integer] :=
 Module[{totalChanges},
  totalChanges = 
   "total" /. 
    Import["http://api.stackoverflow.com/1.1/users/" <> 
      ToString[userID] <> "/reputation?fromdate=0&pagesize=10&page=1",
      "JSON"];
  Join @@ Table[
    "rep_changes" /. 
     Import["http://api.stackoverflow.com/1.1/users/" <> 
       ToString[userID] <> 
       "/reputation?fromdate=0&pagesize=10&page=" <> ToString[page], 
      "JSON"],
    {page, 1, Ceiling[totalChanges/10]}
    ]
  ]

topAnswerers = ({"display_name", 
      "user_id"} /. #) & /@ ("user" /. ("top_users" /. 
      Import["http://api.stackoverflow.com/1.1/tags/mathematica/top-\
answerers/all-time", "JSON"]))

repChangesTopUsers =
  Monitor[Table[
    repChange = 
     ReleaseHold[(Hold[{DateList[
              "on_date" + AbsoluteTime["January 1, 1970"]], 
             "positive_rep" - "negative_rep"}] /. #) & /@ 
        getRepChanges[userID]] // Sort;
    accRepChange = {repChange[[All, 1]], 
       Accumulate[repChange[[All, 2]]]}\[Transpose],
    {userID, topAnswerers[[All, 2]]}
    ], userID];

pl = DateListLogPlot[
  Tooltip @@@ 
   Take[({repChangesTopUsers, topAnswerers[[All, 1]]}\[Transpose]), 
    10], Joined -> True, Mesh -> None, ImageSize -> 1000, 
  PlotRange -> {All, {10, All}}, 
  BaseStyle -> {FontFamily -> "Arial-Bold", FontSize -> 16}, 
  DateTicksFormat -> {"MonthNameShort", " ", "Year"}, 
  GridLines -> {True, None}, 
  FrameLabel -> (Style[#, FontSize -> 18] & /@ {"Date", "Reputation", 
      "Top-10 answerers", ""})]
— Sjoerd সি ডি ভ্রিজ
সূত্র
1
ব্রেট প্রায় এই সঠিক কোডটি জিজ্ঞাসা করে একটি প্রশ্ন পোস্ট করেছেন । প্রশ্নটি ফিট করার জন্য একটি টুইট বা দু'টি দিয়ে সেখানে এটি সবচেয়ে উপযুক্ত। এই প্রশ্নের বিপরীতে আমি আসলেই মূল্যবান হয়ে উঠব।
— rcollyer
@ ক্রলিয়ার ঠিক আছে এটি "সম্প্রদায় উইকি"
— ডাঃ বেলিসারিয়াস
@ বিলেসারিয়াস আমি ব্রেটের প্রশ্নের উত্তরে এটি কেবল অনুলিপি করে দিয়েছি ...
— সজোয়ার্ড সি ডি ভ্রিজ
@ সজ্জার্ড আপনার প্লটটি এখানে স্বয়ংক্রিয়ভাবে আপডেট হয় না।
— ডাঃ বেলিসারিয়াস
@ বিলেসারিয়াস আসলে আমি আশা করছিলাম আপনি সেই কাজটি আপনার উপর নিয়ে যাবেন ... ;-)
— সজোয়ার্ড সি ডি ভ্রিজ
13

ক্যাচিং এক্সপ্রেশন

আমি এই ক্রিয়াগুলি কোনও অভিব্যক্তি ক্যাশে করতে খুব সহায়ক বলে মনে করি। এই দুটি ফাংশনের জন্য এখানে আকর্ষণীয় বিষয় হ'ল হোল্ড টেক্সট / সিম্বল ক্যাশে বা ক্যাশেইন্ডেক্সের মূল কী হিসাবে ধারণ করা এক্সপ্রেশনটি নিজেই ব্যবহৃত হয়, যেখানে গাণিতিকের সুপরিচিত স্মৃতিচারণের তুলনায় আপনি কেবলমাত্র ক্যাশে ফলাফল করতে পারেন যদি ফাংশনটিকে এফের মতো সংজ্ঞায়িত করা হয়। [x_]: = f [x] = ... সুতরাং আপনি কোনও কোডের যে কোনও অংশকে ক্যাশে করতে পারেন, এটি কার্যকর যদি কোনও ফাংশন কয়েকবার বলা হয় তবে কোডের কিছু অংশ পুনরায় সংশোধন করা উচিত নয়।

তার আর্গুমেন্ট থেকে একটি অভিব্যক্তি স্বাধীনভাবে ক্যাশে।

SetAttributes[Cache, HoldFirst];
c:Cache[expr_] := c = expr;

Ex: Cache[Pause[5]; 6]
Cache[Pause[5]; 6]

দ্বিতীয়বার অভিব্যক্তিটি অপেক্ষা না করে 6 ফেরায়।

একটি উপন্যাসের অভিব্যক্তি ব্যবহার করে একটি অভিব্যক্তি ক্যাশে করা যা ক্যাশেড এক্সপ্রেশনটির আর্গুমেন্টের উপর নির্ভর করতে পারে।

SetAttributes[CacheIndex, HoldRest];
c:CacheIndex[index_,expr_] := c = expr;

Ex: CacheIndex[{"f",2},x=2;y=4;x+y]

যদি Expr গণনা করতে কিছুটা সময় নেয় তবে উদাহরণস্বরূপ ক্যাশেড ফলাফল পুনরুদ্ধার করার জন্য {"f", 2 evalu মূল্যায়ন করা খুব দ্রুত is

স্থানীয় ক্রিয়াকলাপের জন্য এই ক্রিয়াকলাপের পরিবর্তনের জন্য (যেমন ক্যাশে মেমরিটি স্বয়ংক্রিয়ভাবে ব্লক কনস্ট্রাক্টের বাইরে প্রকাশিত হয়) পোস্টটি দেখুন বার বার কল্পনা থেকে বিরত থাকুন

ক্যাশেড মানগুলি মোছা হচ্ছে

ক্যাশেড মানগুলি মুছতে যখন আপনি কোনও ফাংশনের সংজ্ঞাগুলির সংখ্যা জানেন না। আমি বিবেচনা করি যে সংজ্ঞাগুলি তাদের যুক্তিগুলির কোথাও একটি ফাঁকা আছে।

DeleteCachedValues[f_] := 
       DownValues[f] = Select[DownValues[f], !FreeQ[Hold@#,Pattern]&];

ক্যাশেড মানগুলি মুছতে যখন আপনি কোনও ফাংশনের সংজ্ঞা সংখ্যার জানেন (কিছুটা দ্রুত চলে যায়)।

DeleteCachedValues[f_,nrules_] := 
       DownValues[f] = Extract[DownValues[f], List /@ Range[-nrules, -1]];

এটি কোনও ফাংশনের সংজ্ঞাগুলি তাদের ডাউনভ্যালু তালিকার শেষে রয়েছে এমনটি ব্যবহার করে, ক্যাশেড মানগুলি আগে থাকে।

ডেটা এবং অবজেক্টের মতো ফাংশন সঞ্চয় করতে প্রতীক ব্যবহার করা

এছাড়াও অবজেক্টের মতো চিহ্ন ব্যবহার করার জন্য এখানে আকর্ষণীয় ফাংশন রয়েছে।

এটি ইতিমধ্যে সুপরিচিত যে আপনি প্রতীকগুলিতে ডেটা সঞ্চয় করতে পারেন এবং ডাউনভ্যালু ব্যবহার করে দ্রুত এগুলি অ্যাক্সেস করতে পারেন

mysymbol["property"]=2;

আপনি এই সাইটে কোনও পোস্টে কী জমা দিয়েছেন তার উপর ভিত্তি করে এই ফাংশনগুলি ব্যবহার করে একটি চিহ্নের কী (বা বৈশিষ্ট্যগুলি) তালিকা অ্যাক্সেস করতে পারেন:

SetAttributes[RemoveHead, {HoldAll}];
RemoveHead[h_[args___]] := {args};
NKeys[symbol_] := RemoveHead @@@ DownValues[symbol(*,Sort->False*)][[All,1]];
Keys[symbol_] := NKeys[symbol] /. {x_} :> x;

প্রতীকের ডাউনভ্যালুতে থাকা সমস্ত ইনফোগুলি প্রদর্শন করতে আমি এই ফাংশনটি ব্যবহার করি:

PrintSymbol[symbol_] :=
  Module[{symbolKeys},
    symbolKeys = Keys[symbol];
    TableForm@Transpose[{symbolKeys, symbol /@ symbolKeys}]
  ];

অবশেষে এখানে একটি প্রতীক তৈরির একটি সহজ উপায় যা অবজেক্ট ওরিয়েন্টেড প্রোগ্রামিংয়ে কোনও অবজেক্টের মতো আচরণ করে (এটি কেবল ওওপির সর্বাধিক মৌলিক আচরণের পুনরুত্পাদন করে তবে আমি বাক্য গঠনটি মার্জিত দেখতে পাই):

Options[NewObject]={y->2};
NewObject[OptionsPattern[]]:=
  Module[{newObject},
    newObject["y"]=OptionValue[y];

    function[newObject,x_] ^:= newObject["y"]+x;
    newObject /: newObject.function2[x_] := 2 newObject["y"]+x;

    newObject
  ];

বৈশিষ্ট্যগুলি ডাউনভ্যালিউস এবং পদ্ধতি হিসাবে সঞ্চিত থাকে যেটি মডিউল দ্বারা নির্মিত প্রতীকটিতে বিলম্বিত আপলিউগুলি হিসাবে ফিরে আসে। আমি ফাংশন 2 এর সিনট্যাক্সটি খুঁজে পেয়েছি যা গাণিতিকায় ট্রি ডেটা কাঠামোর ফাংশনগুলির জন্য স্বাভাবিক ওও-সিনট্যাক্স ।

প্রতিটি প্রতীকটিতে বিদ্যমান ধরণের মানগুলির তালিকার জন্য, http://references.wolfram.com/mathematica/tutorial/PatternsAndTransformationRules.html এবং http://www.verbeia.com/mathemata/tips/HTMLLinks/Tricks_Misc_4.html দেখুন ।

উদাহরণস্বরূপ এটি চেষ্টা করুন

x = NewObject[y -> 3];
function[x, 4]
x.function2[5]

আপনি যদি এখানে উপলভ্য InheritRules নামে একটি প্যাকেজ ব্যবহার করে অবজেক্টের উত্তরাধিকার অনুকরণ করতে চান তবে আপনি আরও এগিয়ে যেতে পারেন http://library.wolfram.com/infocenter/MathSource/671/

আপনি ফাংশন সংজ্ঞাটি নিউঅবজেক্টে নয় বরং কোনও প্রকারের প্রতীক হিসাবে সংরক্ষণ করতে পারেন, সুতরাং যদি নিউওবজেক্টের পরিবর্তে নিউওবজেক্টটি [newObject] প্রকারটি ফিরে আসে তবে আপনি নিউওবজেক্টের বাইরে (এবং ভিতরে নয়) এর মতো ফাংশন এবং ফাংশন 2 সংজ্ঞায়িত করতে পারেন এবং আগের মতো একই ব্যবহার করতে পারেন ।

function[type[object_], x_] ^:= object["y"] + x;
type /: type[object_].function2[x_] := 2 object["y"]+x;

টাইপ প্রতীকটিতে ফাংশন এবং ফাংশন 2 সংজ্ঞায়িত হয়েছে তা দেখতে আপভ্যালিউস [টাইপ] ব্যবহার করুন।

এই সর্বশেষ বাক্য গঠন সম্পর্কে আরও ধারণা এখানে https://mathematica.stackexchange.com/a/999/66 উপস্থাপন করা হয়েছে ।

সিলেকুইভ্যালেন্টসের উন্নত সংস্করণ

@ ক্রলিয়ার: সিলেক্টিভিয়েলেন্টসকে ভূপৃষ্ঠে আনার জন্য অনেক ধন্যবাদ, এটি একটি আশ্চর্যজনক কাজ। এখানে আরও সম্ভাবনা এবং বিকল্পগুলি ব্যবহার করে উপরে তালিকাভুক্ত সিলেকুইভ্যালেন্টগুলির একটি উন্নত সংস্করণ রয়েছে, এটি ব্যবহার করা সহজ করে।

Options[SelectEquivalents] = 
   {
      TagElement->Identity,
      TransformElement->Identity,
      TransformResults->(#2&) (*#1=tag,#2 list of elements corresponding to tag*),
      MapLevel->1,
      TagPattern->_,
      FinalFunction->Identity
   };

SelectEquivalents[x_List,OptionsPattern[]] := 
   With[
      {
         tagElement=OptionValue@TagElement,
         transformElement=OptionValue@TransformElement,
         transformResults=OptionValue@TransformResults,
         mapLevel=OptionValue@MapLevel,
         tagPattern=OptionValue@TagPattern,
         finalFunction=OptionValue@FinalFunction
      }
      ,
      finalFunction[
         Reap[
            Map[
               Sow[
                  transformElement@#
                  ,
                  {tagElement@#}
               ]&
               , 
               x
               , 
               {mapLevel}
            ] 
            , 
            tagPattern
            , 
            transformResults
         ][[2]]
      ]
   ];

এই সংস্করণটি কীভাবে ব্যবহার করা যায় তার উদাহরণ এখানে দেওয়া হয়েছে:

গাণিতিক সংগ্রহ / সংগ্রহ সঠিকভাবে করুন

আপনি গাণিতিকায় একটি পিভটটেবল ফাংশনটি কীভাবে করবেন?

গাণিতিক দ্রুত 2 ডি বিনিং অ্যালগরিদম

Internal`Bag

ড্যানিয়েল লিচব্লাউ এখানে ক্রমবর্ধমান তালিকার জন্য একটি আকর্ষণীয় অভ্যন্তরীণ ডেটা কাঠামো বর্ণনা করেছেন।

গাণিতিকায় একটি চতুষ্কোণ প্রয়োগ করা

ডিবাগিং ফাংশন

এই দুটি পোস্ট ডিবাগিংয়ের জন্য দরকারী কার্যাদি নির্দেশ করে:

গাণিতিক ব্যবহার করে ছোট বা বড় কোডগুলি লেখার সময় কীভাবে ডিবাগ করবেন? workbench? এমএমএ ডিবাগার? অথবা অন্য কিছু? (এটা দেখাও)

/programming/5459735/the-clearest-way-to-mittedmitted-mathematas- মূল্যায়ন- সিকোয়েন্স / 5527117#5527117 (ট্রেসভিউ)

কোনও প্রোগ্রামের বিভিন্ন অংশ থেকে অভিব্যক্তিগুলি বের করতে এবং সেটিকে একটি প্রতীক হিসাবে সংরক্ষণ করার জন্য শস্য এবং বপনের উপর ভিত্তি করে এখানে আরও একটি ফাংশন রয়েছে।

SetAttributes[ReapTags,HoldFirst];
ReapTags[expr_]:=
   Module[{elements},
      Reap[expr,_,(elements[#1]=#2/.{x_}:>x)&];
      elements
   ];

এখানে একটি উদাহরণ

ftest[]:=((*some code*)Sow[1,"x"];(*some code*)Sow[2,"x"];(*some code*)Sow[3,"y"]);
s=ReapTags[ftest[]];
Keys[s]
s["x"]
PrintSymbol[s] (*Keys and PrintSymbol are defined above*)

অন্যান্য উৎস

শেখার উদ্দেশ্যে আকর্ষণীয় লিঙ্কগুলির একটি তালিকা:

ম্যাথমেটিকা ​​শেখার সংস্থানগুলির একটি সংগ্রহ

এখানে আপডেট হয়েছে: https://mathematica.stackexchange.com/a/259/66

— ফায়সু
সূত্র
সম্পর্কিত: " মেমরির সাথে একটি ক্রিয়াকলাপ তৈরি করার সর্বোত্তম উপায় "। ডাব্ল্যাচ সেখানে সাধারণ ফাংশনটির একটি আশ্চর্যজনক উদাহরণ দিয়েছে যা এটির মানগুলি কেবল মনে রাখে না তবে সেগুলি একটি ফাইলে লিখে এবং পুনরায় চালু করার সময় পিছনে পড়ে।
— আলেক্সি পপকভ
1
সম্পর্কিত: " গাণিতিক: কীভাবে প্রতীক হিসাবে ক্যাশে সাফ করবেন, অর্থাত্ আনসেট প্যাটার্ন-মুক্ত ডাউনভ্যালিউস "। এই প্রশ্নটি কীভাবে মানক f[x_] := f[x] = some codeস্মৃতিচারণ ব্যবহার করে ক্যাশে সাফ করবেন shows
— সাইমন
7
+1 টি একটা চমৎকার প্রতীকের সুবিধা নেই যে ঘটিয়েছে একটি ক্যাশে ফাংশন, যেমন মধ্যে সংজ্ঞার বাম দিকে পুনরাবৃত্তি করা প্রয়োজন: c:Cache[expr_] := c = expr।
— WReach
এর চমৎকার রূপ SelectEquivalents। যদিও আমি মনে করি, আমি TagOnElementদ্বিতীয় প্যারামটিকে ডিফল্ট হিসাবে রেখেছি Identityকারণ এটি তাদের মধ্যে সবচেয়ে বেশি ব্যবহৃত হয়। আমি মনে করি না যে আমি অন্তর্ভুক্ত করেছি FinalOp, কারণ এটি এর মধ্যে পরিচালনা করা যেতে পারে OpOnTaggedElems। আমি বিকল্পগুলির নামগুলিও ছোট করতাম, কারণ দৈর্ঘ্যটি টাইপ করা জটিল করে তোলে। ব্যবহার করে দেখুন TagFunction, TransformElement, TransformResults, এবং TagPatternপরিবর্তে। উভয়ই, TagPatternএবং MapLevelকার্যকারিতার দুর্দান্ত সংযোজন এবং সামগ্রিকভাবে একটি ভাল পুনর্লিখন।
— rcollyer
আপনার মন্তব্য rcollyer জন্য ধন্যবাদ। আমি এটি অ্যাকাউন্টে নিয়েছি এবং কোডের পঠনযোগ্যতাও উন্নত করেছি। আমি ফাইনাল ফাংশনটি রাখি কারণ এটি ফলের ফলাফলের উপর পরিচালিত হয়, উদাহরণস্বরূপ আপনি যদি নিজের চূড়ান্ত ফলাফলটিকে ট্যাগগুলি দিয়ে সাজিয়ে রাখতে চান যদি আপনি তা রাখেন।
— ফায়সৌ
12

আমার ইউটিলিটি ফাংশনগুলি (আমি এগুলি এমএএসএইচ-এ অন্তর্নির্মিত করেছি, যা প্রশ্নের উল্লেখ রয়েছে):

pr = WriteString["stdout", ##]&;            (* More                           *)
prn = pr[##, "\n"]&;                        (*  convenient                    *)
perr = WriteString["stderr", ##]&;          (*   print                        *)
perrn = perr[##, "\n"]&;                    (*    statements.                 *)
re = RegularExpression;                     (* I wish mathematica             *)
eval = ToExpression[cat[##]]&;              (*  weren't so damn               *)
EOF = EndOfFile;                            (*   verbose!                     *)
read[] := InputString[""];                  (* Grab a line from stdin.        *)
doList[f_, test_] :=                        (* Accumulate list of what f[]    *)
  Most@NestWhileList[f[]&, f[], test];      (*  returns while test is true.   *)
readList[] := doList[read, #=!=EOF&];       (* Slurp list'o'lines from stdin. *)
cat = StringJoin@@(ToString/@{##})&;        (* Like sprintf/strout in C/C++.  *)
system = Run@cat@##&;                       (* System call.                   *)
backtick = Import[cat["!", ##], "Text"]&;   (* System call; returns stdout.   *)
slurp = Import[#, "Text"]&;                 (* Fetch contents of file as str. *)
                                            (* ABOVE: mma-scripting related.  *)
keys[f_, i_:1] :=                           (* BELOW: general utilities.      *)
  DownValues[f, Sort->False][[All,1,1,i]];  (* Keys of a hash/dictionary.     *)
SetAttributes[each, HoldAll];               (* each[pattern, list, body]      *)
each[pat_, lst_, bod_] := ReleaseHold[      (*  converts pattern to body for  *)
  Hold[Cases[Evaluate@lst, pat:>bod];]];    (*   each element of list.        *)
some[f_, l_List] := True ===                (* Whether f applied to some      *)
  Scan[If[f[#], Return[True]]&, l];         (*  element of list is True.      *)
every[f_, l_List] := Null ===               (* Similarly, And @@ f/@l         *)
  Scan[If[!f[#], Return[False]]&, l];       (*  (but with lazy evaluation).   *)
— dreeves
সূত্র
"প্রতিটি" ফাংশন জন্য, দেখুন stackoverflow.com/questions/160216/foreach-loop-in-mathematica
— dreeves
11

একটি কৌশল যা আমি ব্যবহার করেছি, যা আপনাকে সর্বাধিক অন্তর্নির্মিত ফাংশনগুলি খারাপ যুক্তি দিয়ে কাজ করার মঞ্জুরি দেয় (কোনও বার্তা প্রেরণ করে এবং পুরো ফর্মটিকে অবমূল্যায়ন করে ফেরত দিয়ে) Conditionযখন কোনও সিদ্ধান্তে ব্যবহৃত হয় তখন কাজ করার এক বিড়ম্বনা কাজে লাগায়। যদি fooকেবলমাত্র একটি যুক্তি দিয়ে কাজ করা উচিত:

foo[x_] := x + 1;
expr : foo[___] /; (Message[foo::argx, foo, Length@Unevaluated[expr], 1]; 
                    False) := Null; (* never reached *)

আপনার যদি আরও জটিল চাহিদা থাকে তবে স্বতন্ত্র ফাংশন হিসাবে যুক্তির বৈধতা এবং বার্তা উত্পন্নকরণের ফ্যাক্ট করা সহজ। আপনি Conditionকেবল বার্তা উত্পন্ন করার বাইরেও পার্শ্ব প্রতিক্রিয়া ব্যবহার করে আরও বিস্তৃত জিনিস করতে পারেন , তবে আমার মতে তাদের বেশিরভাগই "sleazy হ্যাক" বিভাগে পড়ে এবং সম্ভব হলে এড়ানো উচিত।

এছাড়াও, "ধাতব প্রোগ্রামিং" বিভাগে, আপনার কাছে যদি গাণিতিক প্যাকেজ ( .m) ফাইল থাকে তবে আপনি "HeldExpressions"উপাদানটি আবৃত করে ফাইলটির সমস্ত অভিব্যক্তি পেতে পেতে পারেন HoldComplete। এটি পাঠ্য-ভিত্তিক অনুসন্ধানগুলি ব্যবহারের চেয়ে জিনিসকে ট্র্যাকিংকে আরও সহজ করে তুলেছে। দুর্ভাগ্যক্রমে, নোটবুকের সাহায্যে একই জিনিস করার সহজ উপায় নেই তবে নীচের মতো কিছু ব্যবহার করে আপনি সমস্ত ইনপুট এক্সপ্রেশন পেতে পারেন:

inputExpressionsFromNotebookFile[nb_String] :=
 Cases[Get[nb],
  Cell[BoxData[boxes_], "Input", ___] :>
   MakeExpression[StripBoxes[boxes], StandardForm],
  Infinity]

শেষ অবধি, আপনি Moduleরেফারেন্স প্রকারের সমতুল্য তৈরি করতে লেজিক্যাল ক্লোজারগুলি অনুকরণ করে এমন সত্যটি ব্যবহার করতে পারেন । এখানে একটি সাধারণ স্ট্যাক (যা Conditionবোনাস হিসাবে পরিচালনা করার ক্ষেত্রে ত্রুটি ব্যবহার করে):

ClearAll[MakeStack, StackInstance, EmptyQ, Pop, Push, Peek]
 With[{emptyStack = Unique["empty"]},
  Attributes[StackInstance] = HoldFirst;
  MakeStack[] :=
   Module[{backing = emptyStack},
    StackInstance[backing]];

  StackInstance::empty = "stack is empty";

  EmptyQ[StackInstance[backing_]] := (backing === emptyStack);

  HoldPattern[
    Pop[instance : StackInstance[backing_]]] /;
    ! EmptyQ[instance] || (Message[StackInstance::empty]; False) :=
   (backing = Last@backing; instance);

  HoldPattern[Push[instance : StackInstance[backing_], new_]] :=
   (backing = {new, backing}; instance);

  HoldPattern[Peek[instance : StackInstance[backing_]]] /;
    ! EmptyQ[instance] || (Message[StackInstance::empty]; False) :=
   First@backing]

এখন আপনি একটি তালিকার উপাদানগুলি অকারণে নিষ্প্রভ উপায়ে বিপরীত ক্রমে মুদ্রণ করতে পারেন!

With[{stack = MakeStack[], list},
 Do[Push[stack, elt], {elt, list}];

 While[!EmptyQ[stack],
  Print[Peek@stack];
  Pop@stack]]
— Pillsy
সূত্র
1
HeldExpressionsপ্যাকেজগুলিতে উপাদানগুলির জন্য +1 , সে সম্পর্কে অজানা ছিল। আমি সাধারণত স্ট্রিং হিসেবে আমদানি করা হয়েছিল এবং তারপর ব্যবহার ToExpressionসঙ্গে HoldCompleteগত ARG হিসাবে। ব্যবহার সংক্রান্ত Conditionবার্তাগুলির জন্য - এই অন্তত 1994 সাল থেকে প্যাকেজ লিখিত একটি প্রমিত কৌশল মাধ্যমে অধ্যবসায় সংক্রান্ত হয়েছে ModuleVars - আমি একটি দীর্ঘ সময় আগে আপনার Mathgroup উপর পোস্ট ছিল: groups.google.com/group/comp.soft- sys.math.mathematica /… (এই থ্রেডে আমার তৃতীয় পোস্ট), এটি একই লাইন বরাবর এবং ব্যবহারের কয়েকটি অনর্থক উদাহরণের সাথে এর লিঙ্ক রয়েছে।
— লিওনিড শিফরিন
@ লিওনিড শিফরিন: আমি এই Conditionবিষয়টিকে সম্ভবত এক সহকর্মীর কাছ থেকে পেয়েছি, তবে এটি বুঝতে পারি নি যে এটি একটি আদর্শ প্রযুক্তি was Moduleরেফারেন্সের ধরণ হিসাবে প্রতীক ব্যবহারের লিঙ্কটি আকর্ষণীয়!
— পিলসি
+1, আমি কখনই এটি ভাবিনি। এই ভাষা সম্পর্কে আমি যত বেশি শিখি তত বেশি শক্তিশালী মনে হয়।
— rcollyer
@ পিলসি এইভাবে স্ট্যাক করার উদ্দেশ্য কী?
— মিঃ উইজার্ড
@ মিঃ উইজার্ড: কৌশলটি বর্ণনা করার জন্য আমি ভাবতে পারি এমন সহজতম মিউটটেবল ডেটা স্ট্রাকচারগুলির মধ্যে একটি বেছে নিয়েছি।
— পিলসি
11

প্রিন্ট করা ছাড়াই মুদ্রণ সিস্টেম প্রতীক সংজ্ঞা

contextFreeDefinition[]নিচে ফাংশন সবচেয়ে সাধারণ প্রেক্ষাপটে prepended ছাড়া একটি প্রতীকের সংজ্ঞা প্রিন্ট করার চেষ্টা করবে। এর পরে সংজ্ঞাটি ওয়ার্কবেঞ্চে অনুলিপি করা যায় এবং পাঠযোগ্যতার জন্য ফর্ম্যাট করা যায় (এটি নির্বাচন করুন, ডান ক্লিক করুন, উত্স -> ফর্ম্যাট)

Clear[commonestContexts, contextFreeDefinition]

commonestContexts[sym_Symbol, n_: 1] := Quiet[
  Commonest[
   Cases[Level[DownValues[sym], {-1}, HoldComplete], 
    s_Symbol /; FreeQ[$ContextPath, Context[s]] :> Context[s]], n],
  Commonest::dstlms]

contextFreeDefinition::contexts = "Not showing the following contexts: `1`";

contextFreeDefinition[sym_Symbol, contexts_List] := 
 (If[contexts =!= {}, Message[contextFreeDefinition::contexts, contexts]];
  Internal`InheritedBlock[{sym}, ClearAttributes[sym, ReadProtected];
   Block[{$ContextPath = Join[$ContextPath, contexts]}, 
    Print@InputForm[FullDefinition[sym]]]])

contextFreeDefinition[sym_Symbol, context_String] := 
 contextFreeDefinition[sym, {context}]

contextFreeDefinition[sym_Symbol] := 
 contextFreeDefinition[sym, commonestContexts[sym]]

withRules []

সতর্কীকরণ: এই ফাংশনটি ভেরিয়েবল একই ভাবে স্থানীয়করণ নেই Withএবং Moduleনা, যার মানে যেমন নেস্টেড স্থানীয়করণ নির্মান প্রত্যাশিত কাজ করবে না। withRules[{a -> 1, b -> 2}, With[{a=3}, b_ :> b]] হবে প্রতিস্থাপন aএবং bনেস্টেড মধ্যে Withএবং Rule, যখন Withএই কাজ করে না।

এটি Withপরিবর্তিত =এবং এর পরিবর্তে নিয়ম ব্যবহার করে :=:

ClearAll[withRules]
SetAttributes[withRules, HoldAll]
withRules[rules_, expr_] :=
  Internal`InheritedBlock[
    {Rule, RuleDelayed},
    SetAttributes[{Rule, RuleDelayed}, HoldFirst];
    Unevaluated[expr] /. rules
  ]

পরীক্ষার সময় এবং ভেরিয়েবল স্থানীয়করণের সময় লিখিত কোড সাফ করার সময় আমি এই দরকারীটি পেয়েছি। মাঝেমধ্যে আমি আকারে পরামিতি তালিকা দিয়ে শেষ {par1 -> 1.1, par2 -> 2.2}। withRulesপ্যারামিটারের মান সহ গ্লোবাল ভেরিয়েবলগুলি ব্যবহার করে আগে লিখিত কোডে ইনজেকশন করা সহজ।

ব্যবহার ঠিক যেমন With:

withRules[
  {a -> 1, b -> 2},
  a+b
]

3 ডি গ্রাফিক্স অ্যান্টিঅ্যালাসিং

এটি অ্যান্টিয়ালিয়াস 3 ডি গ্রাফিক্সের খুব সহজ কৌশল এমনকি আপনার গ্রাফিক্স হার্ডওয়্যার এটিকে স্থানীয়ভাবে সমর্থন না করলেও।

antialias[g_, n_: 3] := 
  ImageResize[Rasterize[g, "Image", ImageResolution -> n 72], Scaled[1/n]]

এখানে একটি উদাহরণ:

গণিত গ্রাফিক্স গণিত গ্রাফিক্স

নোট করুন যে এর জন্য একটি বড় মান nবা একটি বৃহত চিত্রের আকার গ্রাফিক্স ড্রাইভার বাগগুলি প্রকাশ করতে বা প্রত্নতত্ত্বগুলি প্রবর্তন করে to

নোটবুকের কার্যকারিতা ভিন্ন

নোটবুকের ভিন্ন কার্যকারিতা <<AuthorTools`প্যাকেজে পাওয়া যায় এবং (অন্তত 8 সংস্করণে) অননুমোদিত NotebookTools`প্রসঙ্গে। বর্তমানে উন্মুক্ত দুটি নোটবইয়ের আলাদা করার জন্য এটি একটি সামান্য জিইউআই:

PaletteNotebook@DynamicModule[
  {nb1, nb2}, 
  Dynamic@Column[
    {PopupMenu[Dynamic[nb1], 
      Thread[Notebooks[] -> NotebookTools`NotebookName /@ Notebooks[]]], 
     PopupMenu[Dynamic[nb2], 
      Thread[Notebooks[] -> NotebookTools`NotebookName /@ Notebooks[]]], 
     Button["Show differences", 
      CreateDocument@NotebookTools`NotebookDiff[nb1, nb2]]}]
  ]

গণিত গ্রাফিক্স

— জাজাবল্যাক্স
সূত্র
সব সুন্দর হবে, তবে এটি প্রকৃতভাবে ভেরিয়েবলগুলিকে স্থানীয়করণ করে না , যেমন আপনি a = 3; b = 4;উদাহরণস্বরূপ কল দেওয়ার আগে বলার আগে এবং কল করে দেখতে পারেন withRules। পরিবর্তে আপনি নিম্নলিখিত ব্যবহার করে এটি সংরক্ষণ করতে পারেন: SetAttributes[withRules, HoldAll];withRules[rules_, expr_] := Unevaluated[expr] /. Unevaluated[rules]। পার্থক্যগুলি Withতখনকার শব্দার্থবিজ্ঞান : 1. নিয়মের rhides এখন মূল্যায়ন করা হয় না 2. withRulesঅভ্যন্তরীণ স্কোপিং কনস্ট্রাক্টস হিসাবে নামকরণ বিরোধগুলি যেমন Withকরেন তেমন সমাধান করে না । শেষটি বেশ গুরুতর - কেসটির উপর নির্ভর করে ভাল বা খারাপ জিনিস হওয়া।
— লিওনিড শিফরিন
@ লিওনিড আপনি পুরোপুরি ঠিক বলেছেন, মনে হয় পোস্ট দেওয়ার আগে আমি কোডটি সঠিকভাবে পরীক্ষা করা সম্পর্কে কখনই শিখি না ... যখন আমি এটি ব্যবহার করি তখন আমি ব্যবহারিকভাবে কখনও ভেরিয়েবলগুলিকে মান নির্ধারণ করি না, তবে এটি একটি দুর্দান্ত গুরুতর সমস্যা, আপনি ঠিক বলেছেন right সংশোধিত সংস্করণ সম্পর্কে আপনি কী ভাবেন? (আমি সত্যিই সম্পর্কে হ্যান্ডলিং না নেস্টেড পরোয়া করি না With, এস এটি হয় builtin স্থানীয়করণ নির্মান সাথে সবসময় কাজ করে না যেমন। With[{a=1}, Block[{a=2}, a]]আপনি কি মনে ভাল কারণ কেন নেস্টেড এর করবেন না। Blockস্থানীয় ভাষায় লিখুন এখানে ছিল না তখন, নেস্টেড মত Withএবং Moduleকরে?)
— Szabolcs
@ লিওনিড আমি কেবল ব্যবহার Unevaluated[rules]করিনি কারণ আমি আরএইচএসকে x -> 1+1মূল্যায়ন করতে চেয়েছিলাম ।
— Szabolcs
@ লিওনিড আপনি আসলেই ঠিক বলেছেন, নেস্টেড স্থানীয়করণের বিষয়টি বেশ মারাত্মক হতে পারে। আমি মনে করি নেস্টেড Withগুলি স্পট করা এবং এড়ানো সহজ, তবে নিদর্শনগুলি নয়: With[{a = 1}, a_ -> a]অভ্যন্তরীণকে স্থানীয়করণ করার aসময় withRulesনা। আপনি কি জানেন যে ম্যাথমেটিকার অভ্যন্তরীণ স্থানীয়করণের যন্ত্রে অ্যাক্সেস করার এবং নতুন কন্সট্রাক্টস (এর অনুরূপ Rule) যা স্থানীয়করণ করার কোনও উপায় আছে কিনা ? আমি সম্ভবত উত্তরটি পরে মুছে ফেলব কারণ এটি দরকারীের চেয়ে বেশি বিপজ্জনক, তবে আমি এটির সাথে আরও আগে খেলতে চাই।
— Szabolcs
আমি মনে করি আপনার ব্যবহারটি InheritedBlockবেশ দুর্দান্ত এবং সমস্যাটি খুব মার্জিতভাবে সমাধান করে। স্কোপিং কোন্দল হিসাবে, সাধারণত লেসিকাল স্কোপিংয়ের জন্য বাইন্ডিংগুলি "লেক্সিকাল বাইন্ডিং টাইম" এ ঘটে, যা - রান-টাইমের আগে, যখন গতিশীল স্কোপিং রান-টাইমে বাঁধা থাকে, যা এটি ব্যাখ্যা করতে পারে। আপনি এটির অনুরূপ ক্ষেত্রে এটির সাথে বৈষম্য করতে পারেন Module, যা একটি গঠনমূলক ব্যবহারের অনুমতি দেয় (দেখুন উদাহরণস্বরূপ এখানে স্ট্যাকওভারফ্লো / প্রশ্ন / 9৯৯৪113/… দেখুন )। সমস্যাটি হ'ল এর Blockজন্য কিছু প্রতীক প্রয়োজন ...
— লিওনিড শিফ্রিন
9

পুনরাবৃত্ত খাঁটি ফাংশন ( #0) মনে হয় ভাষার একটি অন্ধকার কোণে। এখানে তাদের ব্যবহারের কয়েকটি তুচ্ছ উদাহরণ রয়েছে, যেখানে এটি সত্যই কার্যকর (এমন নয় যে তারা এটি না করেই করা যায় না)। নীচের জোড় হিসাবে উল্লিখিত প্রান্তগুলির একটি তালিকা দেওয়া গ্রাফের সাথে সংযুক্ত উপাদানগুলি সন্ধান করার জন্য নীচে একটি সুন্দর সংক্ষিপ্ত এবং যুক্তিসঙ্গতভাবে দ্রুত ফাংশন:

ClearAll[setNew, componentsBFLS];
setNew[x_, x_] := Null;
setNew[lhs_, rhs_]:=lhs:=Function[Null, (#1 := #0[##]); #2, HoldFirst][lhs, rhs];

componentsBFLS[lst_List] := Module[{f}, setNew @@@ Map[f, lst, {2}];
   GatherBy[Tally[Flatten@lst][[All, 1]], f]];

এখানে যা ঘটে তা হ'ল আমরা প্রথমে প্রতিটি শীর্ষবিন্দুতে একটি ডামি প্রতীকটি ম্যাপ করি এবং তারপরে এমন একটি পথ সেট করি যা {f[5],f[10]}বলুন, তার f[5]পরে মূল্যায়ন করবে f[10]। রিকার্সিভ খাঁটি ফাংশনটি একটি পাথ f[1]=f[3],f[3]=f[4],f[4]=f[2], ...সংক্ষেপক হিসাবে ব্যবহৃত হয় ( স্মৃতি রচনাটি এমনভাবে স্থাপন করতে যাতে দীর্ঘ চেইনের পরিবর্তে , যখন উপাদানটির একটি নতুন "রুট" সন্ধান করা হয় তখনই স্মৃতিযুক্ত মানগুলি সংশোধন হয়। এটি একটি তাত্পর্যপূর্ণ গতি দেয়। যেহেতু আমরা অ্যাসাইনমেন্টটি ব্যবহার করি, আমাদের এটি হোল্ডএল হওয়া দরকার যা এটি আরও বেশি অস্পষ্ট এবং আরও আকর্ষণীয় করে তোলে)। এই ফাংশনটি ফ্রেড সাইমনস, স্যাজাবলাক্স হরভাট, ডাঃ মজোরবোলো এবং সত্যই আপনার সাথে জড়িত ও অন-লাইন ম্যাথগ্রুপ আলোচনার ফলাফল। উদাহরণ:

In[13]:= largeTest=RandomInteger[{1,80000},{40000,2}];

In[14]:= componentsBFLS[largeTest]//Short//Timing
Out[14]= {0.828,{{33686,62711,64315,11760,35384,45604,10212,52552,63986,  
     <<8>>,40962,7294,63002,38018,46533,26503,43515,73143,5932},<<10522>>}}

এটি অবশ্যই একটি অন্তর্নির্মিত তুলনায় অনেক ধীর, কিন্তু কোড আকারের জন্য, বেশ দ্রুত এখনও আইএমও।

আরেকটি উদাহরণ: লিঙ্কিত Selectতালিকাগুলি এবং পুনরাবৃত্ত বিশুদ্ধ ফাংশনগুলির উপর ভিত্তি করে এখানে পুনরাবৃত্তিযোগ্য উপলব্ধি :

selLLNaive[x_List, test_] :=
  Flatten[If[TrueQ[test[#1]],
     {#1, If[#2 === {}, {}, #0 @@ #2]},
     If[#2 === {}, {}, #0 @@ #2]] & @@ Fold[{#2, #1} &, {}, Reverse[x]]];

উদাহরণ স্বরূপ, 

In[5]:= Block[
         {$RecursionLimit= Infinity},
         selLLNaive[Range[3000],EvenQ]]//Short//Timing

Out[5]= {0.047,{2,4,6,8,10,12,14,16,18,20,22,24,26,28,30,
 <<1470>>,2972,2974,2976,2978,2980,2982,2984,2986,2988,2990,
  2992,2994,2996,2998,3000}}

তবে এটি যথাযথভাবে টেল রিকার্সিভ নয়, এবং বৃহত্তর তালিকার জন্য স্ট্যাকটি (কার্নেল ক্র্যাশ করবে) উড়িয়ে দেবে। এখানে লেজ-পুনরাবৃত্তি সংস্করণ:

selLLTailRec[x_List, test_] :=
Flatten[
 If[Last[#1] === {},
  If[TrueQ[test[First[#1]]],
   {#2, First[#1]}, #2],
  (* else *)
  #0[Last[#1],
   If[TrueQ[test[First[#1]]], {#2, First[#1]}, #2]
   ]] &[Fold[{#2, #1} &, {}, Reverse[x]], {}]];

উদাহরণ স্বরূপ, 

In[6]:= Block[{$IterationLimit= Infinity},
       selLLTailRec[Range[500000],EvenQ]]//Short//Timing
Out[6]= {2.39,{2,4,6,8,10,12,14,16,18,20,22,
       <<249978>>,499980,499982,499984,499986,499988,499990,499992,
        499994,499996,499998,500000}}
— লিওনিড শিফরিন
সূত্র
সংযুক্ত উপাদানগুলির জন্য ফাংশনটি এখনও আমার প্রিয় :-)
— স্যাজাবলস
@ সাজাবল্যাকস হ্যাঁ, এটি বেশ দুর্দান্ত। আপনি এবং ফ্রেড এর বেশিরভাগ কাজ করেছিলেন, ববি এবং আমি কেবল কয়েকটি সংশোধনকারী আইআইআরসি যুক্ত করেছি।
— লিওনিড শিফরিন
8

এটি স্ট্যান ওয়াগনের বইয়ের রেসিপি ... অন্তর্নির্মিত প্লট যখন নির্ভুলতার অভাবের কারণে ক্ষতিকারক আচরণ করে তখন এটি ব্যবহার করুন

Options[PrecisePlot] = {PrecisionGoal -> 6};
PrecisePlot[f_, {x_, a_, b_}, opts___] := Module[{g, pg},
   pg = PrecisionGoal /. {opts} /. Options[PrecisePlot];
   SetAttributes[g, NumericFunction];
   g[z_?InexactNumberQ] := Evaluate[f /. x -> z];
   Plot[N[g[SetPrecision[y, \[Infinity]]], pg], {y, a, b},
    Evaluate[Sequence @@ FilterRules[{opts}, Options[Plot]]]]];

আমি প্রায়শই ক্রিস্টজান কান্নাইক-এর নিম্নলিখিত কৌশলগুলি ব্যবহার করি যখন ম্যাথমেটিকার নিম্নমানের থেকে "অভিধানের মতো" আচরণ দরকার

index[downvalue_, 
   dict_] := (downvalue[[1]] /. HoldPattern[dict[x_]] -> x) // 
   ReleaseHold;
value[downvalue_] := downvalue[[-1]];
indices[dict_] := 
  Map[#[[1]] /. {HoldPattern[dict[x_]] -> x} &, DownValues[dict]] // 
   ReleaseHold;
values[dict_] := Map[#[[-1]] &, DownValues[dict]];
items[dict_] := Map[{index[#, dict], value[#]} &, DownValues[dict]];
indexQ[dict_, index_] := 
  If[MatchQ[dict[index], HoldPattern[dict[index]]], False, True];

(* Usage example: *)
(* Count number of times each subexpression occurs in an expression *)
expr = Cos[x + Cos[Cos[x] + Sin[x]]] + Cos[Cos[x] + Sin[x]]
Map[(counts[#] = If[indexQ[counts, #], counts[#] + 1, 1]; #) &, expr, Infinity];
items[counts]

যখন মূল্যায়নের ফলাফলগুলি বিভ্রান্ত হয় তখন কখনও কখনও এটি মূল্যায়নের পদক্ষেপগুলিকে একটি পাঠ্য ফাইলে ফেলে দিতে সহায়তা করে

SetAttributes[recordSteps, HoldAll];
recordSteps[expr_] :=
 Block[{$Output = List@OpenWrite["~/temp/msgStream.m"]}, 
  TracePrint[Unevaluated[expr], _?(FreeQ[#, Off] &), 
   TraceInternal -> True];
  Close /@ $Output;
  Thread[Union@
    Cases[ReadList["~/temp/msgStream.m", HoldComplete[Expression]], 
     symb_Symbol /; 
       AtomQ@Unevaluated@symb && 
        Context@Unevaluated@symb === "System`" :> 
      HoldComplete@symb, {0, Infinity}, Heads -> True], HoldComplete]
  ]

(* Usage example: *)
(* puts steps of evaluation of 1+2+Sin[5]) into ~/temp/msgStream.m *)
recordSteps[1+2+Sin[5]]
— ইয়ারোস্লাভ বুলাটোভ
সূত্র
একটি ব্যবহারের নমুনা দুর্দান্ত হবে। আপনার কাছে সময় পেলে একটি পোস্ট করার চেষ্টা করুন।
— ডঃ বেলিসারিয়াস
আপনি ক্রিস্টজানকে চেনেন? আমি হেলসিঙ্কিতে তাঁর সাথে একই গ্রুপে কাজ করতাম। সুন্দর ছেলে, ছোট্ট পৃথিবী।
— টিমো
নাহ, ওয়েবে তার কোডটি পেয়ে গেছে। আসলে, কোডটিতে একটি ছোট বাগ ঠিক করার জন্য তাকে ইমেল করার চেষ্টা করা হয়েছিল, তবে তার ওয়েবপৃষ্ঠায় ইমেলটি আর কাজ করে না
— ইয়ারোস্লাভ বুলাটোভ
8

দলিলহীন কমান্ড-লাইন বিকল্পগুলি -batchinputএবং-batchoutput ব্যবহার করে ব্যাচ মোডে ম্যাথ কার্নেল চালানো সম্ভব :

math -batchinput -batchoutput < input.m > outputfile.txt

(যেখানে input.mব্যাচ ইনপুট ফাইলটি নতুন লাইনের চরিত্রের সাথে শেষ outputfile.txtহচ্ছে , এটি সেই ফাইল যা আউটপুট পুনঃনির্দেশিত হবে)।

ইন ম্যাথামেটিকাল । বনাম> = 6 MathKernel অনথিভুক্ত কম্যান্ড-লাইন বিকল্প আছে:

-noicon

যা ম্যাথ কার্নেলের টাস্কবারে (অন্তত উইন্ডোজের নিচে) দৃশ্যমান আইকন থাকবে কিনা তা নিয়ন্ত্রণ করে।

ফ্রন্টইন্ডে (কমপক্ষে v.5 থেকে) অননুমোদিত কমান্ড-লাইন বিকল্প রয়েছে

-b

যা স্প্ল্যাশ-স্ক্রিনটি অক্ষম করে এবং ম্যাথমেটিকা ফ্রন্টএন্ড চালানোর মঞ্জুরি দেয়

এবং বিকল্প

-directlaunch

যা সিস্টেম রেজিস্ট্রিতে .nb ফাইলগুলির সাথে সম্পর্কিত সংস্করণটি প্রবর্তন করার পরিবর্তে ইনস্টল করা সর্বশেষতম ম্যাথমেটিকা সংস্করণ চালু করে এমন প্রক্রিয়াটি অক্ষম করে ।

আরেকটি উপায় এটি সম্ভবত করতে হয় :

ইনস্টলেশন ডিরেক্টরিতে ম্যাথমেটিকা.এক্সই বাইনারি চালু করার পরিবর্তে সিস্টেমফিলস \ ফ্রন্টএন্ড \ বাইনারিস \ উইন্ডোজে ম্যাথমেটিকা.এক্সই বাইনারি চালু করুন। পূর্ববর্তীটি একটি সহজ লঞ্চার প্রোগ্রাম যা ইউজার ইন্টারফেসের অনুলিপিগুলিতে চলমান নোটবুকগুলি খোলার জন্য অনুরোধগুলি পুনর্নির্দেশের পক্ষে সবচেয়ে চেষ্টা করে। পরেরটি হল ইউজার ইন্টারফেস বাইনারি নিজেই।

গ্লোবাল ফ্রন্টএন্ড বিকল্পটি সেট করার সাথে সর্বশেষ কমান্ড লাইন বিকল্পটি একত্রিত করার সুবিধাজনক VersionedPreferences->True যা ইনস্টল করা বিভিন্ন গণিত সংস্করণের মধ্যে পছন্দগুলি ভাগ করা অক্ষম করে :

SetOptions[$FrontEnd, VersionedPreferences -> True]

( উপরেরগুলি ইনস্টল করা অতি সাম্প্রতিক গণিত সংস্করণে মূল্যায়ন করা উচিত ))

ইন ম্যাথামেটিকাল 8 এই পছন্দসমূহ ডায়ালগে নিয়ন্ত্রিত হয় সিস্টেম ফলকে, সেটিং অধীনে "তৈরি করুন এবং সংস্করণ নির্দিষ্ট সামনে শেষ পছন্দগুলি বজায় রাখা" ।

অননুমোদিত কী -h(উইন্ডোজের কোড) ব্যবহার করে ফ্রন্টএন্ডের কমান্ড-লাইন বিকল্পগুলির অপূর্ণ তালিকা পাওয়া সম্ভব :

SetDirectory[$InstallationDirectory <> 
   "\\SystemFiles\\FrontEnd\\Binaries\\Windows\\"];
Import["!Mathematica -h", "Text"]

দেয়:

Usage:  Mathematica [options] [files]
Valid options:
    -h (--help):  prints help message
    -cleanStart (--cleanStart):  removes existing preferences upon startup
    -clean (--clean):  removes existing preferences upon startup
    -nogui (--nogui):  starts in a mode which is initially hidden
    -server (--server):  starts in a mode which disables user interaction
    -activate (--activate):  makes application frontmost upon startup
    -topDirectory (--topDirectory):  specifies the directory to search for resources and initialization files
    -preferencesDirectory (--preferencesDirectory):  specifies the directory to search for user AddOns and preference files
    -password (--password):  specifies the password contents
    -pwfile (--pwfile):  specifies the path for the password file
    -pwpath (--pwpath):  specifies the directory to search for the password file
    -b (--b):  launches without the splash screen
    -min (--min):  launches as minimized

অন্যান্য বিকল্পের মধ্যে রয়েছে:

-directLaunch:  force this FE to start
-32:  force the 32-bit FE to start
-matchingkernel:  sets the frontend to use the kernel of matching bitness
-Embedding:  specifies that this instance is being used to host content out of process

ম্যাথ কার্নেল এবং ফ্রন্টএন্ডের অন্যান্য সম্ভাব্য উপকারী কমান্ড-লাইন বিকল্প রয়েছে? জানা থাকলে শেয়ার করুন।

সম্পর্কিত প্রশ্ন ।

— আলেক্সি পপকভ
সূত্র
"মিলছে সাক্ষ্য?" ওটার মানে কি?
— মিঃ উইজার্ড
@ মিঃ উইজার্ড সম্ভবত এই বিকল্পটির সাথে বিকল্পের সাথে -32মিল রেখে কেবলমাত্র 64৪ -বিট সিস্টেমের মধ্যেই একটি ধারণা রয়েছে এবং এর অর্থ হ'ল ফ্রন্টইন্ড দ্বারা ব্যবহৃত ম্যাথ কার্নেলের বেনিফিট অপারেটিং সিস্টেমের (bit৪ বিট) সাক্ষ্য মিলবে। দেখে মনে হচ্ছে অন্যান্য ক্ষেত্রে এই বিকল্পটি কোনও পরিবর্তন করবে না।
— আলেক্সি পপকভ
7

আমার প্রিয় হ্যাকগুলি হ'ল ছোট কোড-উত্পাদক ম্যাক্রোগুলি যা আপনাকে একটি সংক্ষিপ্তের সাথে স্ট্যান্ডার্ড বয়লারপ্লিট কমান্ডগুলির একগুচ্ছ প্রতিস্থাপন করতে দেয়। বিকল্পভাবে, আপনি নোটবুক খোলার / তৈরি করার জন্য কমান্ড তৈরি করতে পারেন।

আমার প্রতিদিনের ম্যাথমেটিকা ​​ওয়ার্কফ্লোতে আমি কিছু সময়ের জন্য এটি ব্যবহার করছি। আমি নিজেকে নীচের অনেকগুলি সম্পাদন করতে দেখেছি:

  1. একটি নোটবুকের একটি ব্যক্তিগত প্রসঙ্গ আছে, লোড প্যাকেজ (গুলি) আমার দরকার, এটি স্বয়ংক্রিয় সংরক্ষণ করুন।
  2. এই নোটবুকটির সাথে কিছুক্ষণ কাজ করার পরে, আমি "ব্যক্তিগত" নোটবুকটিতে যে সংজ্ঞাগুলি ব্যবহার করেছি তার অ্যাক্সেস থাকার পরে, আমি একটি নিজস্ব নোটবুকে একটি পৃথক নোটবুকে স্ক্র্যাচ কম্পিউটেশন কিছুটা ফেলে দিতে চাই। যেহেতু আমি ব্যক্তিগত প্রসঙ্গটি সেট আপ করেছি, এর জন্য ম্যানুয়ালি te প্রসঙ্গপথটি সামঞ্জস্য করতে হবে

হাতছাড়া করে এই সমস্ত করা একটি ব্যথা, তাই আসুন স্বয়ংক্রিয়ভাবে! প্রথমত, কিছু ইউটিলিটি কোড:

(* Credit goes to Sasha for SelfDestruct[] *)
SetAttributes[SelfDestruct, HoldAllComplete];
SelfDestruct[e_] := (If[$FrontEnd =!= $Failed,
   SelectionMove[EvaluationNotebook[], All, EvaluationCell]; 
   NotebookDelete[]]; e)

writeAndEval[nb_,boxExpr_]:=(
    NotebookWrite[nb,  CellGroupData[{Cell[BoxData[boxExpr],"Input"]}]];
    SelectionMove[nb, Previous, Cell]; 
    SelectionMove[nb, Next, Cell];
    SelectionEvaluate[nb];
)

ExposeContexts::badargs = 
  "Exposed contexts should be given as a list of strings.";
ExposeContexts[list___] := 
 Module[{ctList}, ctList = Flatten@List@list; 
  If[! MemberQ[ctList, Except[_String]],AppendTo[$ContextPath, #] & /@ ctList, 
   Message[ExposeContexts::badargs]];
  $ContextPath = DeleteDuplicates[$ContextPath];
  $ContextPath]

    Autosave[x:(True|False)] := SetOptions[EvaluationNotebook[],NotebookAutoSave->x];

এখন, একটি ম্যাক্রো তৈরি করুন যা নোটবুকে নিম্নলিখিত কক্ষগুলি রাখবে:

SetOptions[EvaluationNotebook[], CellContext -> Notebook]
Needs["LVAutils`"]
Autosave[True]

এবং এখানে ম্যাক্রো রয়েছে:

MyPrivatize[exposedCtxts : ({__String} | Null) : Null]:=
  SelfDestruct@Module[{contBox,lvaBox,expCtxtBox,assembledStatements,strList},
    contBox = MakeBoxes[SetOptions[EvaluationNotebook[], CellContext -> Notebook]];
    lvaBox = MakeBoxes[Needs["LVAutils`"]];

    assembledStatements = {lvaBox,MakeBoxes[Autosave[True]],"(*********)"};
    assembledStatements = Riffle[assembledStatements,"\[IndentingNewLine]"]//RowBox;
    writeAndEval[InputNotebook[],contBox];
    writeAndEval[InputNotebook[],assembledStatements];
    If[exposedCtxts =!= Null,
       strList = Riffle[("\"" <> # <> "\"") & /@ exposedCtxts, ","];
       expCtxtBox = RowBox[{"ExposeContexts", "[", RowBox[{"{", RowBox[strList], "}"}], "]"}];
       writeAndEval[InputNotebook[],expCtxtBox];
      ]
 ]

এখন যখন আমি টাইপ করি MyPrivatize[]তা ব্যক্তিগত প্রসঙ্গ তৈরি করে এবং আমার মানক প্যাকেজটি লোড করে। এখন আসুন একটি কমান্ড তৈরি করুন যা তার নিজস্ব প্রসঙ্গের সাথে একটি নতুন স্ক্র্যাচ নোটবুক খুলবে (যাতে আপনি বুনো ত্যাগের মাধ্যমে সংজ্ঞা সংশোধন করার ঝুঁকি ছাড়াই হ্যাক করতে পারেন), তবে আপনার বর্তমান প্রেক্ষাপটে অ্যাক্সেস থাকতে পারে।

SpawnScratch[] := SelfDestruct@Module[{nb,boxExpr,strList},
    strList = Riffle[("\"" <> # <> "\"") & /@ $ContextPath, ","];
    boxExpr = RowBox[{"MyPrivatize", "[",
        RowBox[{"{", RowBox[strList], "}"}], "]"}];
    nb = CreateDocument[];
    writeAndEval[nb,boxExpr];
]

এটি সম্পর্কে দুর্দান্ত জিনিস হ'ল SelfDestructকমান্ডটি চালিত হওয়ার কারণে এটি বর্তমান নোটবুকটিতে কোনও চিহ্ন রাখে না - যা ভাল, কারণ অন্যথায় এটি কেবল বিশৃঙ্খলা সৃষ্টি করবে।

অতিরিক্ত স্টাইল পয়েন্টগুলির জন্য, আপনি এই ম্যাক্রোগুলি ব্যবহার করে কীওয়ার্ড ট্রিগার তৈরি করতে পারেন InputAutoReplacements, তবে আমি এটি পাঠকের অনুশীলন হিসাবে ছেড়ে দেব।

— লিও আলেকসেয়েভ
সূত্র
7

পেজউইথ -> অসীম সহ পুটঅ্যাপেন্ড

ইন ম্যাথামেটিকাল ব্যবহার PutAppendকমান্ড অন্তর্বর্তী কম্পিউটেশন ফলাফল সঙ্গে একটি চলমান লগ ফাইল বজায় রাখার জন্য সবচেয়ে সহজবোধ্য উপায়। এটি PageWith->78কোনও ফাইলে এক্সপ্রেশন রফতানি করার সময় এটি ডিফল্ট সেটিং দ্বারা ব্যবহার করে এবং তাই প্রতিটি মধ্যবর্তী আউটপুট লগের মধ্যে কেবল একটি লাইন নেবে এমন কোনও গ্যারান্টি নেই।

PutAppendকোনও বিকল্প নিজেই নেই তবে এর মূল্যায়ণগুলি সনাক্ত করে এটি প্রকাশ করে যে এটি OpenAppendফাংশনের উপর ভিত্তি করে যা PageWithবিকল্প রয়েছে এবং SetOptionsকমান্ড দ্বারা এটির ডিফল্ট মান পরিবর্তন করতে দেয় :

In[2]:= Trace[x>>>"log.txt",TraceInternal->True]
Out[2]= {x>>>log.txt,{OpenAppend[log.txt,CharacterEncoding->PrintableASCII],OutputStream[log.txt,15]},Null}

সুতরাং আমরা PutAppendসেট করে একবারে একটি মাত্র লাইন যুক্ত করতে পারি :

SetOptions[OpenAppend, PageWidth -> Infinity]

হালনাগাদ

একটা হল বাগ সংস্করণ 10 (সংস্করণ 11.3 সংশোধন) চালু: SetOptionsআর আচরণকে প্রভাবিত OpenWriteএবং OpenAppend।

PutAppendস্পষ্ট PageWidth -> Infinityবিকল্পের সাথে আপনার নিজস্ব সংস্করণটি প্রয়োগ করা একটি কাজের লক্ষণ :

Clear[myPutAppend]
myPutAppend[expr_, pathtofile_String] :=
 (Write[#, expr]; Close[#];) &[OpenAppend[pathtofile, PageWidth -> Infinity]]

নোট করুন যে আমরা এই উত্তরে WriteStringযেমনটি দেখানো হয়েছে তার মাধ্যমেও এটি বাস্তবায়ন করতে পারি তবে এই ক্ষেত্রে প্রাথমিকভাবে অভিব্যক্তিটিকে সংশ্লিষ্ট মাধ্যমে রূপান্তর করা প্রয়োজন ।InputFormToString[expr, InputForm]

— আলেক্সি পপকভ
সূত্র
6

আমি শুধু এই অন্তর্ভুক্তির জন্য আমার প্যাকেজ একজনের কাছ থেকে খুঁজছেন ছিল, এবং কিছু বার্তা আমি সংজ্ঞায়িত যে কাজ বিস্ময়ের পাওয়া যায়নি: Debug::<some name>। ডিফল্টরূপে, এগুলি বন্ধ করা আছে, সুতরাং বেশি ওভারহেড উত্পাদন করবেন না। তবে, আমি তাদের সাথে আমার কোডটি লিটারে ফেলে দিতে পারি এবং কিছুটা কোড কীভাবে আচরণ করছে তা সঠিকভাবে খুঁজে বের করার প্রয়োজন হলে সেগুলি চালু করতে পারি।

— rcollyer
সূত্র
সহায়তা> সংস্করণ ২.০ থেকে (১৯৯১ সালে প্রকাশিত), ডিবাগকে ট্রেস দ্বারা বরখাস্ত করা হয়েছে।
— ডাঃ বেলিসারিয়াস
1
@ বিলেসারিয়াস, আপনি বিষয়টিটি মিস করেছেন। এটি উভয়ই Debugনয় বা Traceকার্যও নয়; এটি আমি তৈরি করা বার্তাগুলির একটি সেট যা আমি নিজের কোডটি ইচ্ছামত চালু / বন্ধ করার সাথে জাগ্রত করতে পারি। এগুলি শব্দের সাথে উপস্থাপিত হয় Debug, একইভাবে usageফাংশনের নামের সাথে একটি চিত্র পূর্বরূপযুক্ত হয়। এটি coutসি ++ কোডে বিবৃতিগুলির গুচ্ছ স্থাপনের মতো একই কার্যকারিতা সরবরাহ করে ।
— rcollyer
1
ওহ দুঃখিত. আমি বিভ্রান্ত হয়ে পড়েছিলাম কারণ "কিন্ডারগার্টেন থেকে আমি কখনই না শিখতে পেরেছি" "রাজধানী দেশগুলির জন্য": ডি
— ডাঃ বেলিসারিয়াস
6

অন্তর্নির্মিত স্কোপিং নির্মাণ সম্পর্কে আমাকে যে জিনিসগুলি বিরক্ত করে তার মধ্যে একটি হ'ল তারা স্থানীয় ভেরিয়েবলের সমস্ত সংজ্ঞা একবারে মূল্যায়ন করে, তাই আপনি উদাহরণস্বরূপ লিখতে পারবেন না

With[{a = 5, b = 2 * a},
    ...
]

কিছুক্ষণ আগে আমি উইথনেস্ট নামে একটি ম্যাক্রো নিয়ে এসেছি যা আপনাকে এটি করতে অনুমতি দেয়। আমি এটি সুবিধাজনক বলে মনে করি, যেহেতু এটি আপনাকে যেমন কিছু না করে ভেরিয়েবল বাইন্ডিংগুলি স্থানীয় রাখতে দেয়

Module[{a = 5,b},
    b = 2 * a;
    ...
]

পরিশেষে, আমি এটি করতে সবচেয়ে ভাল উপায়টি হ'ল একটি বিশেষ চিহ্ন ব্যবহার করে বাইন্ডিংয়ের তালিকার উপরে পুনরাবৃত্তি করা সহজতর করে এবং এই চিহ্নটি গোপন রাখতে আমি সংজ্ঞাটি তার নিজস্ব প্যাকেজে রেখেছি। কারও কারও কাছে এই সমস্যার সহজ সমাধান আছে?

যদি আপনি এটি ব্যবহার করে দেখতে চান তবে নিম্নলিখিত ফাইলটিকে একটি ফাইলের মধ্যে রাখুন Scoping.m:

BeginPackage["Scoping`"];

WithNest::usage=
"WithNest[{var1=val1,var2=val2,...},body] works just like With, except that
values are evaluated in order and later values have access to earlier ones.
For example, val2 can use var1 in its definition.";

Begin["`Private`"];

(* Set up a custom symbol that works just like Hold. *)
SetAttributes[WithNestHold,HoldAll];

(* The user-facing call.  Give a list of bindings and a body that's not
our custom symbol, and we start a recursive call by using the custom
symbol. *)
WithNest[bindings_List,body:Except[_WithNestHold]]:=
WithNest[bindings,WithNestHold[body]];

(* Base case of recursive definition *)
WithNest[{},WithNestHold[body_]]:=body;

WithNest[{bindings___,a_},WithNestHold[body_]]:=
WithNest[
{bindings},
WithNestHold[With[List@a,body]]];

SyntaxInformation[WithNest]={"ArgumentsPattern"->{{__},_}};
SetAttributes[WithNest,{HoldAll,Protected}];

End[];

EndPackage[];
— DGrady
সূত্র
জানুস এই একটি সংস্করণ পোস্ট, এবং MathGroup উপর আপনার প্রশ্নের রেফারেন্স: stackoverflow.com/questions/4190845/custom-notation-question/...
— Mr.Wizard
যে ইশারা জন্য ধন্যবাদ! আমি এই স্টাফটি দেখে কিছুক্ষণ হয়ে গেলাম এবং এই সমস্ত পন্থাগুলি দেখতে আকর্ষণীয়।
— ডিজি গ্র্যাডি
5

এটি আলবার্তো ডি লুলো লিখেছিলেন, (যিনি স্ট্যাক ওভারফ্লোতে উপস্থিত হন না)।

CopyToClipboard, গণিত 7 এর জন্য (ম্যাথমেটিকা ​​8 এ এটি অন্তর্নির্মিত)

CopyToClipboard[expr_] := 
  Module[{nb}, 
   nb = CreateDocument[Null, Visible -> False, WindowSelected -> True];
   NotebookWrite[nb, Cell[OutputFormData@expr], All];
   FrontEndExecute[FrontEndToken[nb, "Copy"]];
   NotebookClose@nb];

আসল পোস্ট: http://forums.wolfram.com/mathgroup/archive/2010/ জুন / msg00148.html

ক্লিপবোর্ডে সাধারণ দশমিক আকারে বৃহত আসল সংখ্যা অনুলিপি করার জন্য আমি এই রুটিনটি দরকারী বলে খুঁজে পেয়েছি। যেমনCopyToClipboard["123456789.12345"]

Cell[OutputFormData@expr] ঝরঝরে উদ্ধৃতি মুছে ফেলা।

— ক্রিস ডিগেন
সূত্র
5

এই কোডটি একটি প্যালেট তৈরি করে যা নির্বাচন হিসাবে স্ট্যাক এক্সচেঞ্জে একটি চিত্র হিসাবে আপলোড করে। উইন্ডোজে, অতিরিক্ত বাটন সরবরাহ করা হয় যা নির্বাচনের আরও বিশ্বস্ত রেন্ডারিং দেয়।

নোটবুকের ঘরে কোডটি অনুলিপি করুন এবং মূল্যায়ন করুন। তারপরে আউটপুট থেকে প্যালেটটি পপ আউট করুন এবং এটি ব্যবহার করে ইনস্টল করুনPalettes -> Install Palette...

এটি নিয়ে আপনার যদি কোনও সমস্যা হয় তবে এখানে একটি মন্তব্য পোস্ট করুন। নোটবুক সংস্করণটি এখানে ডাউনলোড করুন ।

Begin["SOUploader`"];

Global`palette = PaletteNotebook@DynamicModule[{},

   Column[{
     Button["Upload to SE",
      With[{img = rasterizeSelection1[]},
       If[img === $Failed, Beep[], uploadWithPreview[img]]],
      Appearance -> "Palette"],

     If[$OperatingSystem === "Windows",

      Button["Upload to SE (pp)",
       With[{img = rasterizeSelection2[]},
        If[img === $Failed, Beep[], uploadWithPreview[img]]],
       Appearance -> "Palette"],

      Unevaluated@Sequence[]
      ]
     }],

   (* Init start *)
   Initialization :>
    (

     stackImage::httperr = "Server returned respose code: `1`";
     stackImage::err = "Server returner error: `1`";

     stackImage[g_] :=
      Module[
       {getVal, url, client, method, data, partSource, part, entity,
        code, response, error, result},

       getVal[res_, key_String] :=
        With[{k = "var " <> key <> " = "},
         StringTrim[

          First@StringCases[
            First@Select[res, StringMatchQ[#, k ~~ ___] &],
            k ~~ v___ ~~ ";" :> v],
          "'"]
         ];

       data = ExportString[g, "PNG"];

       JLink`JavaBlock[
        url = "http://stackoverflow.com/upload/image";
        client =
         JLink`JavaNew["org.apache.commons.httpclient.HttpClient"];
        method =
         JLink`JavaNew[
          "org.apache.commons.httpclient.methods.PostMethod", url];
        partSource =
         JLink`JavaNew[
          "org.apache.commons.httpclient.methods.multipart.\
ByteArrayPartSource", "mmagraphics.png",
          JLink`MakeJavaObject[data]@toCharArray[]];
        part =
         JLink`JavaNew[
          "org.apache.commons.httpclient.methods.multipart.FilePart",
          "name", partSource];
        part@setContentType["image/png"];
        entity =
         JLink`JavaNew[
          "org.apache.commons.httpclient.methods.multipart.\
MultipartRequestEntity", {part}, method@getParams[]];
        method@setRequestEntity[entity];
        code = client@executeMethod[method];
        response = method@getResponseBodyAsString[];
        ];

       If[code =!= 200, Message[stackImage::httperr, code];
        Return[$Failed]];
       response = StringTrim /@ StringSplit[response, "\n"];

       error = getVal[response, "error"];
       result = getVal[response, "result"];
       If[StringMatchQ[result, "http*"],
        result,
        Message[stackImage::err, error]; $Failed]
       ];

     stackMarkdown[g_] :=
      "![Mathematica graphics](" <> stackImage[g] <> ")";

     stackCopyMarkdown[g_] := Module[{nb, markdown},
       markdown = Check[stackMarkdown[g], $Failed];
       If[markdown =!= $Failed,
        nb = NotebookCreate[Visible -> False];
        NotebookWrite[nb, Cell[markdown, "Text"]];
        SelectionMove[nb, All, Notebook];
        FrontEndTokenExecute[nb, "Copy"];
        NotebookClose[nb];
        ]
       ];

     (* Returns available vertical screen space,
     taking into account screen elements like the taskbar and menu *)


     screenHeight[] := -Subtract @@
        Part[ScreenRectangle /. Options[$FrontEnd, ScreenRectangle],
         2];

     uploadWithPreview[img_Image] :=
      CreateDialog[
       Column[{
         Style["Upload image to the Stack Exchange network?", Bold],
         Pane[

          Image[img, Magnification -> 1], {Automatic,
           Min[screenHeight[] - 140, 1 + ImageDimensions[img][[2]]]},
          Scrollbars -> Automatic, AppearanceElements -> {},
          ImageMargins -> 0
          ],
         Item[
          ChoiceButtons[{"Upload and copy MarkDown"}, \
{stackCopyMarkdown[img]; DialogReturn[]}], Alignment -> Right]
         }],
       WindowTitle -> "Upload image to Stack Exchange?"
       ];

     (* Multiplatform, fixed-width version.
        The default max width is 650 to fit Stack Exchange *)
     rasterizeSelection1[maxWidth_: 650] :=
      Module[{target, selection, image},
       selection = NotebookRead[SelectedNotebook[]];
       If[MemberQ[Hold[{}, $Failed, NotebookRead[$Failed]], selection],

        $Failed, (* There was nothing selected *)

        target =
         CreateDocument[{}, WindowSelected -> False, Visible -> False,
           WindowSize -> maxWidth];
        NotebookWrite[target, selection];
        image = Rasterize[target, "Image"];
        NotebookClose[target];
        image
        ]
       ];

     (* Windows-only pixel perfect version *)
     rasterizeSelection2[] :=
      If[
       MemberQ[Hold[{}, $Failed, NotebookRead[$Failed]],
        NotebookRead[SelectedNotebook[]]],

       $Failed, (* There was nothing selected *)

       Module[{tag},
        FrontEndExecute[
         FrontEndToken[FrontEnd`SelectedNotebook[], "CopySpecial",
          "MGF"]];
        Catch[
         NotebookGet@ClipboardNotebook[] /.
          r_RasterBox :>
           Block[{},
            Throw[Image[First[r], "Byte", ColorSpace -> "RGB"], tag] /;
              True];
         $Failed,
         tag
         ]
        ]
       ];
     )
   (* Init end *)
   ]

End[];
— স্যাজাবল্যাক্স
সূত্র
4

আমি নিশ্চিত যে প্রচুর লোকেরা এমন পরিস্থিতিটির মুখোমুখি হয়েছে যেখানে তারা কিছু জিনিস চালায়, এটি উপলব্ধি করে যে এটি কেবল প্রোগ্রামটিকে আটকে রাখেনি, তবে তারা শেষ 10 মিনিটের জন্যও সংরক্ষণ করেনি!

সম্পাদনা

কিছু সময়ের জন্য এটির ভোগান্তির পরে, আমি একদিন জানতে পেরেছি যে গণিত কোডের মধ্যে থেকে কেউ স্বয়ংক্রিয় সংরক্ষণ তৈরি করতে পারে । আমি মনে করি যে অটো-সেভ ব্যবহার করে অতীতে আমাকে অনেক সাহায্য করেছে এবং আমি সর্বদা অনুভব করেছি যে সম্ভাবনা নিজেই এমন একটি জিনিস যা অনেক লোকই জানতে পারে না যে তারা কী করতে পারে।

আমি ব্যবহৃত মূল কোডটি নীচে রয়েছে। মন্তব্যগুলি ধন্যবাদ যে আমি খুঁজে পেয়েছি যে এটি সমস্যাযুক্ত, এবং বিকল্প পদ্ধতিতে এটি করা ভাল ScheduledTaskযা ব্যবহার করে (যা কেবল গণিত 8 এ কাজ করবে )।

এই জন্য কোড খুঁজে পাওয়া যেতে পারে এই উত্তর থেকে Sjoerd C. de Vries (যেহেতু আমি নিশ্চিত যদি এটা ঠিক আছে এখানে কপি, আমি শুধুমাত্র একটি লিঙ্ক যেমন চলে যাচ্ছি না করছি।)

নীচের সমাধানটি ব্যবহার করছে Dynamic। এটি প্রতি 60 সেকেন্ডে নোটবুকটি সংরক্ষণ করবে, তবে দৃশ্যত কেবল যদি এর ঘরটি দৃশ্যমান থাকে । আমি কেবল এখানে সম্পূর্ণ হওয়ার কারণে এটি রেখে যাচ্ছি। (এবং গণিত 6 এবং 7 এর ব্যবহারকারীদের জন্য )

/ সম্পাদনা

এটির সমাধানের জন্য আমি একটি নোটবুকের শুরুতে এই কোডটি ব্যবহার করি:

Dynamic[Refresh[NotebookSave[]; DateString[], UpdateInterval -> 60]]

এটি প্রতি 60 সেকেন্ডে আপনার কাজ সংরক্ষণ করবে।
আমি এটি পছন্দ করি NotebookAutoSave[]কারণ ইনপুট প্রক্রিয়াজাত হওয়ার আগে এটি সংরক্ষণ করে এবং কারণ কিছু ফাইল ইনপুটের চেয়ে বেশি পাঠ্য।

আমি এখানে এটি মূলত খুঁজে পেয়েছি: http://en.wikedia.org/wiki/Talk : গণিতের# ক্রিটিকিজম

নোট করুন যে একবার এই লাইনটি চালানোর পরে, আপনি যদি আপনার ফাইলটি বন্ধ করে এবং পুনরায় খোলেন (ততক্ষণ ডাইনামিক আপডেটিং সক্ষম করা থাকে) সংরক্ষণ করা হবে।

এছাড়াও, যেহেতু ম্যাথেমেটিকায় কোনও পূর্বাবস্থা নেই , তাই আপনার সমস্ত সামগ্রী মুছে ফেলার বিষয়ে সতর্ক থাকবেন, যেহেতু সংরক্ষণগুলি এটিকে অপরিবর্তনীয় করে তুলবে (একটি সতর্কতা পদক্ষেপ হিসাবে, আমি প্রতিটি কোড সমাপ্ত নোটবুক থেকে এই কোডটি সরিয়ে দিই)

— পুনরুদ্ধার
সূত্র
আপনি এটি আলাদা নামের সাথেও সঞ্চয় করতে পারেন (যেমন ফাইলের শেষের দিকে বর্তমান সময় এবং তারিখ যোগ করে) এবং কোনও নির্দিষ্ট ডিরেক্টরিতে ("ব্যাকআপস" বলুন)। এটি সংস্করণ সংস্করণের মত হবে।
— এসিএল
আপনি এর মতো কিছু করতে পারেন NotebookSave[SelectedNotebook[], "work-" <> IntegerString[i] <> ".nb"]; i++তবে আমি মনে করি যে বর্তমান নোটবুকের নামের সাথে কোনও ধরণের রেফারেন্স পুনরাবৃত্ত হয়ে উঠবে।
— tsvikas
2
আমি ভেবেছিলাম Dynamicঅবজেক্টগুলি কেবল দৃশ্যমান হলে তা রিফ্রেশ হবে, সুতরাং আমি নিশ্চিত হতে পারি না যে এই পদ্ধতিটি কাজ করবে যদি উদাহরণস্বরূপ আপনি Dynamicদৃশ্যমান অঞ্চলটি থেকে বস্তুটি স্ক্রোল করে নিন । তারপরেও, আমি চেষ্টা করিনি। যাই হোক না কেন, আমি এটি কেবল একটি পরামর্শ হিসাবে অফার করেছি।
— এসিএল
1
আপনি এটি ব্যবহার করে পরীক্ষা করতে পারেন Dynamic[Refresh[i++, UpdateInterval -> 1, TrackedSymbols -> {}]]। বর্ধিত নম্বরটি দর্শন থেকে স্ক্রোল করুন, এক মিনিট অপেক্ষা করুন, ফিরে স্ক্রোল করুন এবং দেখুন 60০ দ্বারা বৃদ্ধি করা হয়নি About সম্পর্কে UpdateInterval: সাধারণত যদি এটি সম্ভব হয় তবে ব্যবহৃত হয়, তবে যদি আপনার কোডটিতে পরিবর্তনগুলি অন্তর্ভুক্ত থাকে তবে এই পরিবর্তনটি নতুন রিফ্রেশটিকে ট্রিগার করে বিরতি শেষ হয়। উপরের লাইনটি ব্যবহার করে দেখুনTrackedSymbols
— সজোয়ার্ড সি ডি ভ্রিজ
1
@ j0ker5 আমার উপরের কোডটি ব্যবহার করে দেখুন এবং আপনি দেখতে পারেন যে আপডেটআইন্টারভাল সর্বদা আপডেটগুলিকে নির্দিষ্ট ব্যবধানের সাথে ব্যবধান করতে বাধ্য করে না। এই কোডটি দেখায় যে ডায়নামিক কেবল তখনই কাজ করে যদি এতে থাকা কক্ষটি সম্মুখভাগে দৃশ্যমান হয় । এটি দৃষ্টির বাইরে থাকা মুহূর্তটি সত্যিই থামে। লোকেরা তাদের ফাইলগুলি সংরক্ষণ করার জন্য এই কোডটিকে সত্যই বিশ্বাস করতে পারে না কারণ এটি করে না। এটি বিপজ্জনক
— সজোয়ার্ড সি ডি ভ্রিজ
3

আমার SystemFiles/FrontEnd/TextResources/Windows/KeyEventTranslations.trফাইলে এই কীবোর্ড শর্টকাট যুক্ত করার জন্য প্যাকেজগুলি বিকাশ করার সময় আমি এটি সত্যিই দরকারী বলে মনে করি ।

(* Evaluate Initialization Cells: Real useful for reloading library changes. *)

Item[KeyEvent["i", Modifiers -> {Control, Command}],
    FrontEndExecute[
        FrontEndToken[
            SelectedNotebook[],
            "EvaluateInitialization"]]],

প্রত্যেকের পরের জন্য Packagename.mআমি PackagenameTest.nbপরীক্ষার জন্য একটি নোটবুক তৈরি করি এবং পরীক্ষার নোটবুকের প্রথম 2 টি কক্ষ আরম্ভের ঘর হিসাবে সেট করা হয়। প্রথম কক্ষে আমি রাখলাম

Needs["PackageManipulations`"]

লিওনিড দ্বারা লিখিত খুব দরকারী প্যাকেজমানিপুলেশন লাইব্রেরি লোড করতে । দ্বিতীয় কোষে রয়েছে

PackageRemove["Packagename`Private`"]
PackageRemove["Packagename`"]
PackageReload["Packagename`"]

যা সবাই প্রকৃত প্যাকেজ পুনরায় লোড করে। নোট করুন প্রথম দুটি লাইনগুলি কেবলমাত্র Removeসমস্ত চিহ্ন হিসাবে রয়েছে যেমন আমি প্রাসঙ্গিকগুলি যথাসম্ভব পরিষ্কার রাখতে পছন্দ করি।

তারপরে একটি প্যাকেজটি লেখার এবং পরীক্ষার জন্য ওয়ার্কফ্লো এমন কিছু হয়ে যায়।

  1. এতে পরিবর্তনগুলি সংরক্ষণ করুন Packagename.m।
  2. যাও PackagenameTest.nbএবং করতে CTRL + ALT + i।

এটি সূচনা কক্ষগুলির ফলে প্যাকেজটি পুনরায় লোড করে দেয়, যা পরীক্ষার বাস্তবকে সহজ করে তোলে।

— রিভ্স নিক্সেগল
সূত্র
1

নিম্নলিখিত ক্রিয়াকলাপটি কোনও পৃষ্ঠার উপরে ছড়িয়ে থাকা format[expr_]অপরিশোধিত mathematicaএক্সপ্রেশনগুলি ইনডেন্ট / ফর্ম্যাট করতে ব্যবহার করা যেতে পারে

indent[str_String, ob_String, cb_String, delim_String] := 
  Module[{ind, indent, f, tab}, ind = 0; tab = "    ";
   indent[i_, tab_, nl_] := nl <> Nest[tab <> ToString[#] &, "", i];
   f[c_] := (indent[ind, "", " "] <> c <> indent[++ind, tab, "\n"]) /;StringMatchQ[ob, ___ ~~ c ~~ ___];
   f[c_] := (indent[--ind, "", " "] <> c <> indent[ind, tab, "\n"]) /;StringMatchQ[cb, ___ ~~ c ~~ ___];
   f[c_] := (c <> indent[ind, tab, "\n"]) /;StringMatchQ[delim, ___ ~~ c ~~ ___];
   f[c_] := c;
   f /@ Characters@str // StringJoin];
format[expr_] := indent[expr // InputForm // ToString, "[({", "])}", ";"];

(*    
format[Hold@Module[{ind, indent, f, tab}, ind = 0; tab = "    ";
 indent[i_, tab_, nl_] := nl <> Nest[tab <> ToString[#] &, "", i];
 f[c_] := (indent[ind, "", " "] <> c <> indent[++ind, tab, "\n"]) /;StringMatchQ[ob, ___ ~~ c ~~ ___];
 f[c_] := (indent[--ind, "", " "] <> c <> indent[ind, tab, "\n"]) /;StringMatchQ[cb, ___ ~~ c ~~ ___];
 f[c_] := (c <> indent[ind, tab, "\n"]) /;StringMatchQ[delim, ___ ~~ c ~~ ___];
 f[c_] := c;
 f /@ Characters@str // StringJoin]]
*)

রেফ: /codegolf/3088/indent-a-string- using-given- pareheses

— প্রশান্ত ভাতে
সূত্র
বাস্তবে আপনি এটি কী ব্যবহার করছেন? আপনার কোড বা ডেটাতে (তালিকাগুলি ) প্রয়োগ করার সময় আউটপুটটি খুব "মজাদার" হতে পারা যায় format@RandomInteger[10,{3,3}]: পেস্টবিন.com / nUT54Emq যেহেতু আপনার কাছে ইতিমধ্যে বেসিক রয়েছে এবং আপনি এতে আগ্রহী, আপনি কি কোডটি উন্নত করতে পারেন একটি কার্যকরভাবে পঠনযোগ্য ফর্ম্যাটিং উত্পাদন? তারপরে পরবর্তী পদক্ষেপটি হ'ল একটি পেস্ট বোতাম তৈরি করা হবে যা সুন্দরভাবে ইন্টেন্টেড ম্যাথেমেটিক কোড (পছন্দমত মন্তব্য সংরক্ষণের জন্য !!) দিয়ে একটি ইনপুট সেল তৈরি করবে আমার সম্পর্কিত প্রশ্নটিও দেখুন ।
— স্যাজাবলাকস
আমাদের সাইট ব্যবহার করে, আপনি স্বীকার করেছেন যে আপনি আমাদের কুকি নীতি এবং গোপনীয়তা নীতিটি পড়েছেন এবং বুঝতে পেরেছেন ।
Licensed under cc by-sa 3.0 with attribution required.