Mathematica alet çantanızda ne var? [kapalı]

hepimiz Mathematica'nın harika olduğunu biliyoruz, ancak aynı zamanda kritik işlevsellikten de yoksun. Mathematica ile ne tür harici paketler / araçlar / kaynaklar kullanıyorsunuz?

ben düzenlemek (ve bunu yapmak için başka birini davet edeceğiz) bu ana yazı bilimsel araştırmalarda genel uygulanabilirliği üzerinde duruldu ve mümkün olduğunca çok insan yararlı bulacaksınız kaynakları dahil etmek. Bir şey katkıda bulunmaktan çekinmeyin, hatta küçük kod parçacıkları (aşağıda yaptığım gibi zamanlama rutin).

ayrıca, Mathematica 7'de ve ötesinde belgesiz ve kullanışlı özellikler kendinizi buldu ya da bazı kağıt / siteden kazıldı en çok açığız.

bir şey büyük ya da ne yarar sağlar neden kısa bir açıklama veya yorum ekleyin. Eğer bağlı kuruluş bağlantıları ile Amazon kitaplara bağlarsanız, örneğin, bağlantıdan sonra adınızı koyarak, söz edin.


paketler:

  1. LevelScheme Mathematica'nın iyi görünümlü araziler üretme kabiliyetini büyük ölçüde genişleten bir pakettir. Başka bir şey için değilse, çerçeve/eksen keneleri üzerinde çok, çok gelişmiş kontrol için kullanıyorum. En yeni sürümü SciDraw olarak adlandırılır ve bu yıl bir ara piyasaya sürülecektir.
  2. David Park'ın Presentation Package (ABD $ 50 - hiçbir ücret için güncellemeler)
  3. Jeremy Michelson'ın grassmannOps paketi, önemsiz olmayan komütasyon ilişkilerine sahip Grassmann değişkenleri ve operatörleri ile cebir ve hesap yapmak için kaynak sağlar.
  4. John Brown'ın GrassmannAlgebra Grassmann ve Clifford cebirleri ile çalışmak için paket ve kitap.
  5. RISC (sembolik hesaplama Araştırma Enstitüsü) indirmek için kullanılabilir Mathematica (ve diğer diller) için paketleri çeşitli vardır. Özellikle, otomatik teorem kanıtlaması için Theorema ve sembolik toplama, fark denklemleri vb. Için çok sayıda paket var. algoritmik birleştirici grubun yazılım sayfasında .

Araçlar:

  1. MASH Daniel Reeves'in mükemmel Perl komut dosyası aslında Mathematica V7 için komut dosyası desteği sağlar. (Şimdi -script seçeneği ile Mathematica 8 itibariyle inşa.)
  2. an alternate Mathematica shell bir GNU readline girişi ile (yalnızca python, *nix kullanarak)
  3. ColourMaths paketi görsel bir ifadenin parçaları seçmek ve bunları işlemek için izin verir. http://www.dbaileyconsultancy.co.uk/colour_maths/colour_maths.html

Kaynaklar:

  1. Wolfram'ın kendi deposu MathSource , çeşitli uygulamalar için dar dizüstü bilgisayarlar için çok kullanışlı. Ayrıca

    gibi diğer bölümleri de kontrol edin
  2. Mathematica Wikibook .

Kitaplar:

  1. Mathematica programlama: gelişmiş bir giriş Leonid Shifrin tarafından( web , pdf ) Mathematica'da döngüleri için den daha fazla bir şey yapmak istiyorsanız bir okunması gerekir. Burada Leonid sorularını cevaplama zevkine sahibiz.
  2. Mathematica ile Kuantum yöntemleri James F. Feagin tarafından ( amazon )
  3. Mathematica kitap Stephen Wolfram tarafından ( ) ) ( web )
  4. Schaum's Outline ( amazon )
  5. Mathematica in Action tarafından Stan Wagon ( amazon ) - 600 sayfa düzgün örnekler ve Mathematica sürüm 7'ye kadar gider. Görselleştirme teknikleri özellikle iyi, bazıları yazarın üzerinde görebilirsiniz Demonstrations Page .
  6. Mathematica programlama temelleri Richard Gaylord tarafından ( pdf ) - Mathematica programlama Hakkında Bilmeniz Gerekenler çoğu için iyi bir özlü giriş.
  7. O'Reilly 2010 832 pages tarafından yayınlanan Sal Mangano tarafından Mathematica yemek kitabı. - Yazılı iyi bilinen O'Reilly yemek kitabı tarzında: Problem Çözümü. Ara ürünler için.
  8. Mathematica ile diferansiyel denklemler, 3.Ed. Elsevier 2004 Amsterdam Martha L. Abell tarafından, James P. Braselton - yeni başlayanlar için 893 sayfa, aynı zamanda DEs ve Mathematica çözme öğrenin.

belgelenmemiş (veya belgelenmemiş) özellikler:

  1. Mathematica nasıl özelleştirilir klavye kısayolları. Gördün mü? this question .
  2. Mathematica'nın kendi işlevleri tarafından kullanılan desenleri ve işlevleri nasıl denetleyebilirim? Gördün mü? this answer
  3. Mathematica'da GraphPlots için tutarlı boyut nasıl elde edilir? Gördün mü? this question .
  4. Mathematica ile belge ve sunumlar nasıl üretilir. Gördün mü? this question .
141
tarihinde sordu Dr. belisarius 0000-00-00 00:00:00
kaynak

26 ответов

Daha önce bu den bahsettim, ancak en yararlı bulduğum araç, Reap ve Sow davranışını taklit eden/genişleten bir uygulamadır GatherBy :

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

Bu, listeleri herhangi bir kritere göre gruplandırmamı ve bunları süreçte dönüştürmemi sağlar. Çalışma şekli, bir ölçüt işlevinin ( f ) listedeki her öğeyi etiketlemesidir, her öğe daha sonra ikinci bir verilen işlevle dönüştürülür ( g ) ve özel çıkış üçüncü bir işlev tarafından kontrol edilir ( h ). h işlevi iki bağımsız değişkeni kabul eder: bir etiket ve bu etikete sahip toplanan öğelerin bir listesi. Öğeler orijinal siparişlerini korurlar, bu nedenle h = #1& yi ayarlarsanız, örneklerinde için Reap gibi sıralanmamış bir Union alırsınız . Ancak, ikincil işleme için kullanılabilir.

yardımcı programının bir örneği olarak, Wannier90 ile çalışarak, uzamsal olarak bağımlı Hamiltonian'ı her satırın matriste farklı bir unsur olduğu bir dosyaya çıkarır,

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

bu listeyi bir dizi matrise dönüştürmek için, aynı koordinatı içeren tüm alt listeleri topladım, öğe bilgilerini bir kural haline getirdim (yani {i, j} - > Re [Hıj] + i İm[Hıj]) ve daha sonra toplanan kuralları bir SparseArray ile bir liner:

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

dürüst olmak gerekirse, bu benim İsviçre Ordu Bıçağım ve karmaşık şeyleri çok basit hale getiriyor. Diğer araçlarımın çoğu biraz etki alanına özgüdür, bu yüzden muhtemelen onları yayınlamayacağım. Ancak, çoğu, hepsi değilse, bunların SelectEquivalents referans .

Düzenle : GatherBy ifadesinin birden fazla seviyesini GatherBy gibi gruplayamayacağı şekilde tamamen taklit etmez. Ancak, Map , ihtiyacım olan şeylerin çoğu için gayet iyi çalışıyor.

örnek : @Yaroslav Bulatov kendi kendine yeten bir örnek istedi. İşte büyük ölçüde basitleştirilmiş olan araştırmamdan biri. Yani, diyelim ki

düzleminde bir dizi noktamız var
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}}

ve bir dizi simetri işlemi ile puan sayısını azaltmak istiyoruz. (Meraklı için, küçük grup üretiyoruz her nokta.) Bu örnek için,

z ekseni hakkında dört kat dönüş ekseni kullanalım
In[2] := rots = RotationTransform[#, {0, 0, 1}] & /@ (Pi/2 Range[0, 3]);

kullanarak SelectEquivalents bu işlemler altında aynı görüntü kümesini üreten noktaları gruplayabiliriz, yani

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}}}
Eşdeğer noktaları içeren 3 alt liste üreten

. (Not, Union burada kesinlikle önemlidir, çünkü aynı görüntünün her nokta tarafından üretilmesini sağlar. Başlangıçta, Sort kullandım, ancak bir nokta bir simetri ekseninde yatıyorsa, bu eksende dönme altında değişmez ve kendisi için ekstra bir görüntü verir. Yani, Union bu ekstra görüntüleri ortadan kaldırır. Ayrıca, GatherBy aynı sonucu üretecektir.) Bu durumda, noktalar zaten kullanacağım bir formdadır, ancak yalnızca her gruptan bir temsilci noktasına ihtiyacım var ve eşdeğer noktaların sayısını istiyorum. Her noktayı dönüştürmem gerekmediğinden, Identity işlevi ikinci konumda. Üçüncü işlev için dikkatli olmalıyız. Ona geçirilen ilk argüman, {0,0,0} noktası için dört özdeş elemanın bir listesi olan ve sayımı atacağını kullanan rotasyonların altındaki noktaların görüntüleri olacaktır. Ancak, ikinci argüman sadece bu etikete sahip tüm öğelerin bir listesidir, bu nedenle yalnızca {0,0,0} içerecektir. Kodda,

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}}

Not, Bu son adım olabilir

ile kolayca gerçekleştirilebilir
In[5] := {#[[1]], Length[#]}& /@ Out[3]

ancak, bu ve yukarıdaki daha az tam örnek ile çok karmaşık dönüşümlerin en az kodla nasıl mümkün olduğunu görmek kolaydır.

27
cevap rcollyer 2017-05-23 15:18:01
kaynak

Mathematica notebook arayüzü hakkında güzel şeylerden biri herhangi dil, sadece Mathematica ifadeleri değerlendirebilir olmasıdır. Basit bir örnek olarak, içerdiği ifadeyi değerlendirme için işletim sistemi kabuğuna geçiren yeni bir kabuk giriş hücresi türü oluşturmayı düşünün.

önce, bir metinsel komutun dış kabuğa değerlendirilmesini sağlayan bir işlev tanımlayın:

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

ikinci argümana ihtiyaç duyulur ve daha sonra ortaya çıkacak nedenlerden dolayı göz ardı edilir. Sonra, , adı verilen yeni bir stil oluşturmak istiyoruz:

  1. yeni bir dizüstü bilgisayar açın.
  2. menü öğesini seçin Biçim/düzenleme stil sayfası...
  3. iletişim kutusunda, yanında bir stil adı girin: türü Shell .
  4. yeni stilin yanındaki hücre braketini seçin.
  5. menü öğesini seçin hücre / göster ifade
  6. , aşağıda verilen 6. adım ile hücre ifadesinin üzerine yazılır.
  7. bir kez daha, menü öğesini seçin hücre / göster ifade
  8. iletişim kutusunu kapatın.

aşağıdaki hücreyi kullanın Adım 6 metin olarak ifade:

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"]

bu ifadenin çoğu doğrudan yerleşik programı stili oluşturmak kopyalandı. Anahtar değişiklikler bu satırlardır:

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

Evaluatable , hücre için SHİFT+ENTER işlevselliğini sağlar. Değerlendirme, hücre içeriğini ve içerik türünü bağımsız değişkenler olarak geçen CellEvaluationFunction ( shellEvaluate ikinci argümanı yok sayar) diyecektir. CellFrameLabels , kullanıcının bu hücrenin olağandışı olduğunu tanımlamasına izin veren sadece bir güzelliktir.

bunların hepsi yerinde, şimdi bir kabuk ifadesini girip değerlendirebiliriz:

  1. yukarıdaki adımlarda oluşturulan defterde, boş bir hücre oluşturun ve hücre braketini seçin.
  2. menü öğesini seçin Biçim / stil / kabuk .
  3. geçerli bir işletim sistemi kabuk komutu yazın hücreye (örneğin, unix'te 'ls' veya Windows'da 'dir').
  4. SHİFT + ENTER tuşuna basın.

bu tanımlanmış stili merkezi bir şekilde yerleştirilmiş bir stil sayfasında tutmak en iyisidir. Ayrıca, shellEvaluate gibi değerlendirme işlevleri en iyi DeclarePackage init.m kullanarak saplamalar olarak tanımlanır . Bu faaliyetlerin her ikisinin ayrıntıları bu yanıtın kapsamı dışındadır.

bu işlevsellik ile, bir ilgi herhangi bir sözdizimi giriş ifadeleri içeren defterleri oluşturabilirsiniz. Değerlendirme fonksiyonu saf Mathematica yazılmış veya dış ajans değerlendirme herhangi bir veya tüm parçaları temsilci olabilir. CellEpilog , CellProlog ve CellDynamicExpression gibi hücre değerlendirmesiyle ilgili diğer kancalar olduğunu unutmayın .

ortak bir desen, giriş ifade metnini geçici bir dosyaya yazmayı, dosyayı bazı dilde derlemeyi, çıkış hücresindeki nihai ekran için çıktıyı programlayın ve yakalayın. Bu tür tam bir çözüm uygularken ele alınacak birçok ayrıntı var (hata mesajlarını düzgün bir şekilde yakalamak gibi), ancak bunun gibi şeyleri yapmanın mümkün olmadığı gerçeğini takdir etmelidir, ancak pratik.

kişisel bir notta, dizüstü bilgisayar arayüzünü programlama evrenimin merkezi yapan bu gibi özellikler.

Güncelleme

aşağıdaki yardımcı işlev, bu tür hücreleri oluşturmak için yararlıdır:

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]
  )

bu şekilde kullanılır:

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

şimdi, shellCell[] değerlendirilirse, giriş hücresi silinir ve içeriğini bir kabuk komutu olarak değerlendiren yeni bir giriş hücresi ile değiştirilir.

55
cevap WReach 2011-12-14 19:56:37
kaynak

Todd Gayley (Wolfram Research) sadece bana rastgele kod ile yerleşik fonksiyonları "sarmak" için izin veren güzel bir kesmek göndermek. Bu yararlı enstrümanı paylaşmam gerektiğini hissediyorum. Aşağıdaki benim Todd cevabı question .

biraz ilginç (?) tarih: "sarma" için hack bu tarz bir dahili fonksiyon robby Villegas ve I tarafından 1994 etrafında icat edildi, ironik bir şekilde işlev mesajı için ErrorHelp adlı paket O zamanlar Mathematica Journal için yazdığım. Kullanılmış o zamandan beri birçok kişi tarafından birçok kez. İçeriden biraz var. trick, ama bence kanonik hale geldiğini söylemek adil yerleşik bir kod tanımına kendi kodunuzu enjekte etme yolu işlev. İşi güzel halleder. Elbette şunları koyabilirsiniz istediğiniz herhangi bir özel bağlam içine $ hsg değişken.

Unprotect[Message];

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

Protect[Message];
32
cevap Alexey Popkov 2017-05-23 14:47:23
kaynak

bu tam bir kaynak değil, bu yüzden burada cevaplar bölümüne atıyorum, ancak hız sorunlarını bulurken çok yararlı buldum (ne yazık ki Mathematica programlamasının büyük bir kısmı).

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};

kullanımı daha sonra sadece [email protected] .

Düzenle: Mr. Wizard, Throw ve Catch ile daha basit bir sürüm sağladı ve ayrıştırmak biraz daha kolay:

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

Düzenle: işte acl ( buradan alınan ) bir sürüm:

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]
24
cevap Timo 2017-05-23 14:54:48
kaynak

Internal`InheritedBlock

son zamanlarda resmi haber grubunda Daniel Lichtblau bu mesajı Internal`InheritedBlock gibi yararlı fonksiyonun varlığını öğrendim.

anladığım kadarıyla, Internal`InheritedBlock , Block kapsamı içinde giden bir işlevin bir kopyasını geçmesine izin verir:

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]

bu işlevin yerleşik olarak değiştirilmesi gereken herkes için çok yararlı olabileceğini düşünüyorum fonksiyonlar geçici olarak!

blok ile karşılaştırma

bazı işlevi tanımlamamıza izin verin:

a := Print[b]

şimdi Block kapsamına bu fonksiyonun bir kopyasını geçmek istiyoruz. Naif deneme istediğimiz şeyi vermez:

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

During evaluation of In[9]:= b

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

şimdi Block ilk argümanında gecikmiş tanımı kullanmaya çalışıyor (belgesiz bir özelliktir):

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

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

During evaluation of In[3]:= b

biz bu durumda a çalıştığını görmek ama Block kapsamı içinde orijinal a bir kopyasını yok.

şimdi Internal`InheritedBlock deneyelim:

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

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

Block kapsamının içinde a için orijinal tanımın bir kopyasını aldık ve a için küresel tanımı etkilemeden istediğimiz şekilde değiştirebiliriz !

20
cevap Alexey Popkov 2011-08-03 14:06:10
kaynak

Mathematica keskin bir araçtır, ancak untyped behaviour ve çığ şifreli tanılama iletileri ile kesebilir . Bununla başa çıkmanın bir yolu, bu deyim aşağıdaki işlevleri tanımlamaktır:

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

sık sık atlamak için cazip olduğum çok sayıda boilerplate. Özellikle prototipleme yaparken, Mathematica'da çok şey olur. Yani, bir makro kullanıyorum bana çok daha az boilerplate ile, disiplinli kalmanızı sağlar define denir.

define temel kullanımı şöyle:

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

fact[5]

120

ilk başta çok fazla görünmüyor, ancak bazı gizli faydalar var. define sağlayan ilk hizmet, tanımlanan simgeye ClearAll otomatik olarak uygulanmasıdır. Bu, başlangıç sırasında ortak bir olay olan artık tanımların bulunmamasını sağlar bir fonksiyonun geliştirilmesi.

ikinci hizmet, tanımlanan işlevin otomatik olarak "kapalı"olmasıdır. Bu, işlevin bir mesaj yayınlayacağı ve tanımlardan biriyle eşleşmeyen bir bağımsız değişken listesi ile çağrılırsa iptal edeceği anlamına gelir:

fact[-1]

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

bu , çok yaygın bir hata sınıfı yakalayan define birincil değerdir.

başka bir kolaylık belirtmek için özlü bir yoldur tanımlanan işleve öznitelikler. Listable işlevini yapalım:

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

fact[{3, 5, 8}]

{6, 120, 40320}

normal özniteliklerin hepsine ek olarak define , Open adlı ek bir öznitelik kabul eder . Bu, define , catch-all hata tanımını işleve eklemesini engeller:

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

successor /@ {1, "hi"}

{2, successor["hi"]}

bir işlev için birden çok öznitelik tanımlanabilir:

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

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

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

daha fazla ado olmadan, işte define tanımı:

[email protected]
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:{}] :=
  ( [email protected]
  ; SetAttributes[name, DeleteCases[attributes, Open]]
  ; If[!MemberQ[attributes, Open]
    , def:name[___] := (Message[define::badargs, name, [email protected]]; Abort[])
    ]
  ; body
  ;
  )
def:define[___] := (Message[define::malformed, [email protected]]; Abort[])

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

sergilenen uygulama, basit işlev tanımından daha genel olarak ne Yukarı-değerler ne de körükleme, ne de desenleri destekler. Bununla birlikte, yararlı kalır.

18
cevap WReach 2017-05-23 14:54:48
kaynak

boş bir dizüstü bilgisayar olmadan başlayın

Mathematica'nın boş bir dizüstü bilgisayar ile başlamasından rahatsız oldum. Bu dizüstü bilgisayarı bir komut dosyası ile kapatabilirim, ancak yine de kısaca yanıp sönecektir. Benim kesmek içeren bir dosya Invisible.nb oluşturmaktır:

Notebook[{},Visible->False]

ve bunu Kernel\init.m :

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

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

şimdi Invisible.nb

açarak Mathematica'ya başlıyorum

orada daha iyi bir yol olabilir, ama bu bana iyi hizmet etti.


özelleştirilmiş Fold ve FoldList

Fold[f, x] Fold[f, [email protected], [email protected]]

eşdeğer yapılır

tesadüfen, bunun Mathematica'nın gelecekteki bir versiyonuna dönüşebileceğini düşünüyorum.

sürpriz! Şu anda olmasına rağmen bu, uygulanmıştır belgesiz. Ben Oliver Ruebenkoenig tarafından 2011 yılında uygulandığını haberdar oldum, görünüşe göre Ben bu yayınlanmıştır sonra uzun değil. Teşekkürler Oliver Ruebenkoenig!

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]

buna izin vermek için güncellendi:

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

"Dinamik Bölüm"

Bkz. Mathematica.SE post # 7512 için bir bu fonksiyonun yeni sürümü.

sık sık bir uzunluk dizisine göre bir listeyi bölümlemek istiyorum.

sözde kod örneği:

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

çıktı: {{1,2}, {3,4,5}, {6}}

bununla geldim:

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

daha sonra argüman testi de dahil olmak üzere bununla tamamladım:

dynamicPartition[l_List, p : {_Integer?NonNegative ..}] :=
  dynP[l, p] /; [email protected] >= [email protected]

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

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

üçüncü bağımsız değişken, bölünmüş belirtimin ötesinde öğelere ne olduğunu kontrol eder.


Szabolcs'ın Mathematica Hileleri

en sık kullandığım Yapıştır sekmeli veri paleti

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

Compile

içindeki harici verileri değiştirin

son zamanlarda Daniel Lichtblau bu yöntemi hiç göstermedim daha önce görmüştüm. Bence önemli ölçüde Compile

yarar uzanır
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.}  *)
16
cevap Mr.Wizard 2017-04-13 15:55:36
kaynak

Genel PDF / EMF ihracat sorunları ve çözümleri

1) tamamen beklenmedik ve belgesiz, ama Mathematica ihracat ve ekranda dizüstü görüntülemek için kullanılan birinden farklı stil tanımları bir dizi kullanarak PDF ve EPS biçimlerinde grafikleri kaydeder. Varsayılan olarak, "çalışma" stil ortamında ( ScreenStyleEvironment global $FrontEnd seçeneği için varsayılan değer olan) ekranda görüntülenir ancak "Printout" stil ortamında basılmış ( PrintingStyleEnvironment global $FrontEnd seçeneği için varsayılan değer olan). GIF ve PNG gibi raster formatlarında veya EMF formatında Mathematica grafiklerini dışa aktardığında, dizüstü bilgisayarın içinde göründüğü gibi grafikler üretir. Bu durumda "Working" stil ortamının render için kullanıldığı anlaşılıyor. Ancak, PDF veya EPS formatlarında herhangi bir şeyi dışa aktardığınızda/kaydettiğinizde durum böyle değildir! Bu durumda "Printout" stil ortamı, "çalışma" stil ortamından çok derinden farklı olan varsayılan olarak kullanılır. Her şeyden önce, "Printout" stil ortamı Magnification ila %80 ayarlar . İkincisi, farklı stillerin yazı tipi boyutları için kendi değerlerini kullanır ve bu, orijinal Ekran Gösterimi ile karşılaştırıldığında genarated PDF dosyasındaki tutarsız yazı tipi boyutu değişikliklerine neden olur. İkincisi olarak adlandırılabilir FontSize dalgalanmaları çok can sıkıcı. Ancak, bu PrintingStyleEnvironment global $FrontEnd seçeneğini "çalışma" olarak ayarlayarak önlenebilir:

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

2) EMF formatına dışa aktarma ile ilgili ortak sorun, programların çoğunun (sadece Mathematica değil ) varsayılan boyutta güzel görünen ancak yakınlaştırdığınızda çirkin hale gelen bir dosya oluşturmasıdır. Çünkü metafiles Ekran Çözünürlüğünde örneklendi . Oluşturulan EMF dosyasının kalitesi, orijinal grafik nesnesinin Magnify ile geliştirilebilir, böylece orijinal grafiklerin örneklenmesinin kesinliği çok daha hassas hale gelir. İki dosyayı karşılaştır:

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

bu dosyaları Microsoft Word'e eklerseniz ve yakınlaştırırsanız, ilk "a" nin üzerinde testere dişi olduğunu göreceksiniz, ikincisi ise ( Mathematica 6 ile test edilmiştir).

aracılığıyla başka bir yol ImageResolution tarafından önerildi Chris Degnen (bu seçenek en azından Mathematica 8 başlayarak etkisi vardır):

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

3) içinde Mathematica biz metafile grafik dönüştürmek için üç yol var: Export ile "EMF" (şiddetle tavsiye edilen yol: mümkün olan en yüksek kalitede metafile üretir), Save selection As... menüsü üzerinden öğe ( çok daha az hassas şekil üretir , tavsiye edilmez) ve üzerinden Edit ► Copy As ► Metafile menü öğesi ( şiddetle bu rotaya karşı tavsiye ).

14
cevap Alexey Popkov 2017-05-23 15:02:50
kaynak

popüler talep, kod oluşturmak için top-10 SO answerers arsa (hariç ek açıklamalar ) kullanarak so API .

enter image description here

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", ""})]
13
cevap Sjoerd C. de Vries 2017-05-23 15:02:50
kaynak

önbelleğe alma ifadeleri

bu işlevleri herhangi bir ifadeyi önbelleğe almak için çok yararlı buluyorum. Bu iki işlev için burada ilginç olan şey, tutulan ifadenin kendisinin Hashtable/symbol Cache veya cacheındex'in bir anahtarı olarak kullanılmasıdır; mathematica'daki tanınmış notlamaya kıyasla, işlev F[x_] := f[x] = gibi tanımlanırsa sonucu önbelleğe alabilirsiniz ... Böylece bir kodun herhangi bir bölümünü önbelleğe alabilirsiniz, bu bir işlev çağrılacak ise yararlıdır birkaç kez ancak kodun sadece bazı bölümleri yeniden değerlendirilmemelidir.

bağımsız olarak bağımsız olarak bir ifade önbelleğe almak için.

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

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

ikinci kez ifade beklemeden 6 döndürür.

önbelleğe alınan ifadenin bağımsız değişkenine bağlı bir diğer ad ifadesi kullanarak bir ifade önbelleğe almak için.

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

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

expr hesaplamak için biraz zaman alırsa, çok daha hızlıdır örneğin önbelleğe alınan sonucu almak için {"f",2} değerini değerlendirin.

yerelleştirilmiş bir önbelleğe sahip olmak için bu işlevlerin bir varyasyonu için (yani. önbellek belleği otomatik olarak blok yapısı dışında serbest bırakılır) Bu yazı enterpolasyon

tekrarlanan çağrılardan kaçının

önbelleğe alınmış değerleri silme

bir işlev tanımlarının sayısını bilmediğinizde önbelleğe alınmış değerleri silmek için. Bunu düşünüyorum. tanımların argümanlarında boş bir yeri vardır.

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

bir işlev tanımlarının sayısını bildiğinizde önbelleğe alınmış değerleri silmek için (biraz daha hızlı gider).

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

bu, bir işlev tanımlarının DownValues listesinin sonunda olduğu, önbelleğe alınmış değerlerin daha önce olduğu gerçeğini kullanır.

veri ve nesne benzeri işlevleri depolamak için semboller kullanma

de burada ilginç fonksiyonlar nesneler gibi sembolleri kullanmak için.

zaten iyi sembollerde veri depolamak ve hızlı bir şekilde

DownValues kullanarak erişebilirsiniz bilinmektedir
mysymbol["property"]=2;

bu sitede bir gönderide sunulan dreeves dayalı bu işlevleri kullanarak bir sembolün tuşları (veya özellikleri) listesine erişebilirsiniz:

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

bu işlevi bir sembolün Aşağı değerlerinde bulunan tüm bilgileri görüntülemek için çok kullanıyorum:

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

nihayet burada nesne yönelimli programlamada bir nesne gibi davranan bir sembol oluşturmak için basit bir yoldur (sadece OOP'UN en temel davranışını üretir, ancak sözdizimini zarif buluyorum):

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
  ];

özellikleri olarak depolanır DownValues ve yöntemleri olarak gecikmeli Upvalues döndürülen modül tarafından oluşturulan sembolü. ağacında işlevler için olağan OO-sözdizimi olan function2 sözdizimini buldum Mathematica veri yapısı.

her sembolün sahip olduğu mevcut değer türlerinin listesi için bölümüne bakın http://reference.wolfram.com/mathematica/tutorial/PatternsAndTransformationRules.html ve http://www.verbeia.com/mathematica/tips/HTMLLinks/Tricks_Misc_4.html .

örneğin

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

nesneyi taklit etmek isterseniz daha da ileri gidebilirsiniz ınheritrules adlı bir paketi kullanarak devralma burada kullanılabilir http://library.wolfram.com/infocenter/MathSource/671/

işlev tanımını newObject değil, bir tür sembolünde de saklayabilirsiniz, bu nedenle NewObject türü[newObject] yerine newobject döndürdüyse işlev ve function2'yi böyle tanımlayabilirsiniz dışında NewObject (ve içinde değil) ve daha önce olduğu gibi aynı kullanımı var.

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

kullanım UpValues[type] bu işlev ve function2 türü sembolü tanımlanır görmek için.

bu son sözdizimi hakkında daha fazla fikir burada tanıtıldı https://mathematica.stackexchange.com/a/999/66 .

Selectequivalents geliştirilmiş versiyonu

@ rcollyer: Selectequivalents'i yüzeye getirdiğiniz için çok teşekkürler, inanılmaz bir işlev. İşte yukarıda listelenen selectequivalents geliştirilmiş bir versiyonu daha fazla olasılık ve seçenekleri kullanarak, bu daha kolay kullanmak için yapar.

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[
      {
         [email protected],
         [email protected],
         [email protected],
         [email protected],
         [email protected],
         [email protected]
      }
      ,
      finalFunction[
         Reap[
            Map[
               Sow[
                  [email protected]#
                  ,
                  {[email protected]#}
               ]&
               , 
               x
               , 
               {mapLevel}
            ] 
            , 
            tagPattern
            , 
            transformResults
         ][[2]]
      ]
   ];

İşte bu sürümün nasıl kullanılabileceğine dair örnekler:

kullanarak Mathematica toplamak / düzgün toplamak

Mathematica'da PivotTable işlevi nasıl yaparsınız?

Mathematica hızlı 2D binning algoritması

İç 'Çanta

Daniel Lichtblau burada büyüyen listeleri için ilginç bir iç veri yapısını açıklar.

Mathematica'da bir Quadtree uygulamak

hata ayıklama işlevleri

bu iki mesaj hata ayıklama için yararlı işlevlere işaret eder:

Mathematica kullanarak küçük veya büyük kodları yazarken hata ayıklama nasıl yapılır? tezgah mı? MMA hata ayıklayıcı? ya da başka bir şey? (Showıt)

https://stackoverflow.com/questions/5459735/the-clearest-way-to-represent-mathematicas-evaluation-sequence/5527117#5527117 (TraceView)

Burada bir programın farklı bölgelerinden ifadeleri ayıklamak ve bir sembolde saklamak için biçmek ve ekmek dayalı başka bir işlev var.

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

işte bir örnek

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*)

Diğer Kaynaklar

işte öğrenme amaçlı ilginç bağlantıların bir listesi:

Mathematica öğrenme kaynakları Koleksiyonu

burada güncellendi: https://mathematica.stackexchange.com/a/259/66

13
cevap faysou 2017-05-23 15:18:01
kaynak

yardımcı program işlevlerim (söz konusu söz konusu olan MASH'E inşa ettim):

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[]    *)
  [email protected][f[]&, f[], test];      (*  returns while test is true.   *)
readList[] := doList[read, #=!=EOF&];       (* Slurp list'o'lines from stdin. *)
cat = [email protected]@(ToString/@{##})&;        (* Like sprintf/strout in C/C++.  *)
system = [email protected]@##&;                       (* 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[[email protected], 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).   *)
12
cevap dreeves 2010-11-18 12:36:29
kaynak

kullandığım bir numara, en yerleşik işlevlerin kötü argümanlarla çalışma biçimini taklit etmenizi sağlar (bir mesaj göndererek ve daha sonra tüm formu değerlendirilmemiş olarak döndürerek) Condition bir tanımlamada kullanıldığında çalışır. foo yalnızca bir argüman ile çalışmalıdır:

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

daha karmaşık ihtiyaçlarınız varsa, bağımsız değişken doğrulama ve mesaj oluşturma işlemini bir bağımsız fonksiyon. Condition de sadece mesaj üretmenin ötesinde yan etkileri kullanarak daha ayrıntılı şeyler yapabilirsiniz, ancak bence çoğu "kalitesiz hack" kategorisine girer ve mümkünse kaçınılmalıdır.

ayrıca," metaprogramming " kategorisinde, bir Mathematica paketiniz varsa ( .m ) dosyası, "HeldExpressions" öğesini öğesini HoldComplete ile sarılmış dosyadaki tüm ifadeleri almak için kullanabilirsiniz . Bu yapar metin tabanlı aramaları kullanmaktan çok daha kolay şeyler izleme. Ne yazık ki, aynı şeyi bir dizüstü bilgisayarla yapmanın kolay bir yolu yok, ancak aşağıdaki gibi bir şey kullanarak tüm giriş ifadelerini alabilirsiniz:

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

son olarak, Module referans türleri eşdeğer oluşturmak için sözcük kapakları öykünür gerçeğini kullanabilirsiniz. İşte basit bir yığın (bir varyasyon kullanan Condition bonus olarak hata işleme için hile):

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 = [email protected]; instance);

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

  HoldPattern[Peek[instance : StackInstance[backing_]]] /;
    ! EmptyQ[instance] || (Message[StackInstance::empty]; False) :=
   [email protected]]

şimdi gereksiz kıvrık bir şekilde ters sırayla bir listenin unsurları yazdırabilirsiniz!

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

 While[!EmptyQ[stack],
  Print[[email protected]];
  [email protected]]]
11
cevap Pillsy 2011-02-08 19:31:16
kaynak

baskı sistemi sembol tanımları

aşağıdaki contextFreeDefinition[] işlevi, önceden hazırlanmış en yaygın bağlam olmadan bir sembolün tanımını yazdırmaya çalışacaktır. Tanım daha sonra çalışma tezgahına kopyalanabilir ve okunabilirlik için biçimlendirilebilir (seçin, sağ tıklayın, kaynak -> Biçim)

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]}, 
    [email protected][FullDefinition[sym]]]])

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

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

withRules []

Uyarı: Bu işlev, değişkenleri With ve Module ile aynı şekilde lokalize etmez; bu, iç içe yerelleştirme yapılarının beklendiği gibi çalışmayacağı anlamına gelir. withRules[{a -> 1, b -> 2}, With[{a=3}, b_ :> b]] olacak yerine a ve b iç içe With ve Rule , With bunu yapmaz.

bu = ve := yerine kuralları kullanan With bir varyantı:

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

deney ve yerelleştirme değişkenleri sırasında yazılmış kodu temizlerken bu yararlı buldum. Bazen 1519170920 'şeklinde parametre listeleri ile bitirmek . withRules parametre değerleri ile daha önce genel değişkenler kullanılarak yazılmış kod içine enjekte etmek kolaydır.

kullanım With gibidir:

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

Antialiasing 3D graphics

bu bir grafik donanımınız doğal olarak desteklemese bile, antialias 3D grafiklerine çok basit bir teknik.

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

işte bir örnek:

Mathematica graphics Mathematica graphics

için büyük bir değer n veya büyük bir görüntü boyutu grafik Sürücüsü Hataları ortaya çıkarmak veya eserler tanıtmak eğilimindedir unutmayın.


Notebook diff işlevselliği

Notebook diff işlevselliği <<AuthorTools` paketinde ve belgesiz NotebookTools` bağlamında (en azından sürüm 8'de) mevcuttur. Bu, şu anda açık olan iki Dizüstü Bilgisayarı fark etmek için biraz GUI:

[email protected][
  {nb1, nb2}, 
  [email protected][
    {PopupMenu[Dynamic[nb1], 
      Thread[Notebooks[] -> NotebookTools`NotebookName /@ Notebooks[]]], 
     PopupMenu[Dynamic[nb2], 
      Thread[Notebooks[] -> NotebookTools`NotebookName /@ Notebooks[]]], 
     Button["Show differences", 
      [email protected]`NotebookDiff[nb1, nb2]]}]
  ]

Mathematica graphics

11
cevap Szabolcs 2012-01-09 13:04:49
kaynak

özyinelemeli saf fonksiyonlar ( #0 ) dilin daha koyu köşelerinden biri gibi görünüyor. İşte bunların kullanımının önemsiz olmayan birkaç örneği , bunun gerçekten yararlı olduğu (onsuz yapamayacakları değil). Aşağıdaki, bir grafikte bağlı bileşenleri bulmak için oldukça özlü ve makul derecede hızlı bir işlevdir, köşelerin çiftleri olarak belirtilen kenarların bir listesi göz önüne alındığında:

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[[email protected]][[All, 1]], f]];

burada olan şey, önce kukla bir sembolü haritalamamız köşe sayılarının her biri ve daha sonra bir çift köşe {f[5],f[10]} göz önüne alındığında, f[5] f[10] olarak değerlendirilecek bir yol oluşturdu . Özyinelemeli saf işlevi, f[1]=f[3],f[3]=f[4],f[4]=f[2], ... gibi uzun zincirler yerine, bileşenin yeni bir "kök" keşfedildiğinde, memoize değerler düzeltilecek şekilde bir yol) olarak kullanılır. Bu önemli bir hız-up verir. Çünkü atamayı kullanırız, HoldAll olması gerekir, bu da bu yapıyı yapar daha da belirsiz ve daha çekici ). Bu işlev, Fred Simons, Szabolcs Horvat, DrMajorBob ve sizinkileri gerçekten içeren on Ve off-line Mathgroup tartışmasının bir sonucudur. Örnek:

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>>}}

kesinlikle yerleşik çok daha yavaş, ama kod boyutu için, oldukça hızlı hala IMO.

başka bir örnek: burada Select özyinelemeli gerçekleşme , bağlı listeleri ve özyinelemeli saf fonksiyonları dayalı:

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

örneğin,

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}}

bununla birlikte, düzgün bir şekilde özyinelemeli değildir ve daha büyük listeler için yığını (çekirdeği çöker) patlatacaktır. İşte kuyruk özyinelemeli sürüm:

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]], {}]];

örneğin,

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}} 
9
cevap Leonid Shifrin 2011-03-08 18:09:44
kaynak

bu Stan Wagon'un kitabından tarifi...yerleşik arsa,

hassasiyetinden dolayı düzensiz davrandığında kullanın
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]]]]];

genellikle Kristjan Kannike'nin Mathematica'nın downvalues

den "sözlük benzeri" davranışına ihtiyacım olduğunda aşağıdaki hileyi kullanıyorum
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]

değerlendirme sonuçları kafa karıştırıcı olduğunda, bazen bir metin dosyası

değerlendirme adımları dökümü yardımcı olur
SetAttributes[recordSteps, HoldAll];
recordSteps[expr_] :=
 Block[{$Output = [email protected]["~/temp/msgStream.m"]}, 
  TracePrint[Unevaluated[expr], _?(FreeQ[#, Off] &), 
   TraceInternal -> True];
  Close /@ $Output;
  Thread[[email protected]
    Cases[ReadList["~/temp/msgStream.m", HoldComplete[Expression]], 
     symb_Symbol /; 
       [email protected]@symb && 
        [email protected]@symb === "System`" :> 
      [email protected], {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
cevap Yaroslav Bulatov 2010-12-28 08:46:30
kaynak

belgesiz komut satırı seçenekleri -batchinput kullanarak toplu modunda MathKernel çalıştırmak mümkündür ve -batchoutput :

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

( input.m , yeni satır karakteri ile biten toplu giriş dosyasıdır, outputfile.txt , çıktıların yönlendirileceği dosyadır).

İn Mathematica v. > = 6 MathKernel belgesiz komut satırı seçeneği vardır:

-noicon

Mathkernel'in görev çubuğunda (en azından Windows altında) görünür simgeye sahip olup olmadığını kontrol eder.

ön uç (en azından v. 5'ten) belgesiz komut satırı seçeneğine sahiptir

-b

sıçrama ekranını devre dışı bırakır ve Mathematica çok daha hızlı

çalıştırmak için izin verir

ve

seçeneği
-directlaunch

hangi en son Mathematica sürümünü başlatan mekanizmayı devre dışı bırakır sürümü ile ilişkili sürümü başlatmak yerine .sistem kayıt defterindeki nb dosyaları.

bunu yapmanın başka bir yolu muhtemelen :

yerine başlatılması 19.exe ikili kurulum dizini, başlatmak 19.exe ikili SystemFiles \ FrontEnd \ Binaries \ Windows. Eski basit bir başlatıcısı en zor deneyen program açılış isteklerini yönlendirme notebookların kopyalarını çalıştırmak için kullanıcı arayüzü. İkincisi ise kullanıcı arayüzü ikili kendisi.

farklı Mathematica arasındaki tercihlerin paylaşımını devre dışı bırakır VersionedPreferences->True küresel FrontEnd seçeneği ayarı ile son komut satırı seçeneği birleştirmek için kullanışlıdır sürümleri :

SetOptions[$FrontEnd, VersionedPreferences -> True]

(yukarıdaki en son değerlendirilmelidir Mathematica sürümü yüklü.)

in Mathematica 8 Bu, sistem bölmesinde, "sürüm özel ön uç tercihlerini oluştur ve koru" ayarı altında Tercihler iletişim kutusunda kontrol edilir .

mümkün belgesiz anahtar -h (Windows için kod) kullanarak ön uç komut satırı seçeneklerinin eksik listesini alın:

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

verir:

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

diğer seçenekler şunlardır:

-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

MathKernel ve Frontend'in potansiyel olarak yararlı komut satırı seçenekleri var mı? Lütfen biliyorsanız paylaşın.

ilgili soru .

8
cevap Alexey Popkov 2017-05-23 15:10:12
kaynak

en sevdiğim kesmek, bir grup standart boilerplate komutlarını kısa bir kodla değiştirmenize izin veren küçük kod üreten makrolardır. Alternatif olarak, dizüstü bilgisayarlar açmak/oluşturmak için komutlar oluşturabilirsiniz.

burada bir süredir günlük Mathematica iş akışımda kullandığım şey. Kendimi çok şey yaparak buldum:

  1. dizüstü bilgisayarın özel bir içeriğe sahip olmasını sağlayın, ihtiyacım olan paket (ler) yükleyin, yapın otomatik kaydetme.
  2. bu dizüstü bilgisayarla bir süre çalıştıktan sonra, "ana" dizüstü bilgisayarda kullandığım tanımlara erişirken, kendi özel bağlamıyla ayrı bir dizüstü bilgisayarda çizik hesaplamaları atmak isterim. Özel bağlamı kurduğumdan, bu, $ContextPath
  3. değerini manuel olarak ayarlamayı gerektirir

tüm bunları elle tekrar yapmak bir acıdır, bu yüzden otomatikleştirelim! İlk olarak, bazı yardımcı program kodu:

(* 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 = [email protected]@list; 
  If[! MemberQ[ctList, Except[_String]],AppendTo[$ContextPath, #] & /@ ctList, 
   Message[ExposeContexts::badargs]];
  $ContextPath = DeleteDuplicates[$ContextPath];
  $ContextPath]

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

şimdi, aşağıdaki hücreleri deftere koyacak bir makro oluşturalım:

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

ve işte makro:

MyPrivatize[exposedCtxts : ({__String} | Null) : Null]:=
  [email protected][{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];
      ]
 ]

şimdi MyPrivatize[] yazdığımda özel bağlam oluşturur ve standart paketimi yükler. Şimdi kendi özel bağlamıyla yeni bir çizik defteri açacak bir komut oluşturalım (böylece vidalama riski olmadan orada vahşi bir şekilde hackleyebilirsiniz tanımlar), ancak mevcut bağlamlara erişimi vardır.

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

bununla ilgili havalı şey, SelfDestruct nedeniyle, komut çalışırken geçerli defterde iz bırakmaz-bu iyi, çünkü aksi takdirde dağınıklık yaratacaktır.

ekstra stil noktaları için, InputAutoReplacements kullanarak bu makrolar için anahtar kelime Tetikleyicileri oluşturabilirsiniz, ancak bunu okuyucu için bir egzersiz olarak bırakacağım.

7
cevap Leo Alekseyev 2011-05-07 02:46:25
kaynak

Pagewidth ile PutAppend -> Infinity

in Mathematica PutAppend komutunun kullanılması, Ara hesaplamaların sonuçları ile çalışan bir günlük dosyasını korumanın en basit yoludur. Ancak, ifadeleri bir dosyaya dışa aktarırken varsayılan olarak PageWith->78 ayarını kullanır ve bu nedenle, her Ara çıkışın günlükte yalnızca bir satır alacağını garanti etmez.

PutAppend değil herhangi bir seçeneğe sahip olun, ancak değerlendirmelerini izlemek, PageWith seçeneğine sahip olan ve varsayılan değerini SetOptions komutu ile değiştirmeyi sağlayan OpenAppend işlevine dayandığını ortaya koymaktadır:

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

bu yüzden PutAppend ayarlayarak bir seferde sadece bir satır eklemek için alabilirsiniz:

SetOptions[OpenAppend, PageWidth -> Infinity]

güncelleme

bir hata var (sürüm 11.3 sabit) sürüm 10 tanıtılan: SetOptions artık OpenWrite ve OpenAppend davranışını etkiler .

bir geçici çözüm açık PageWidth -> Infinity seçeneği ile PutAppend kendi sürümünü uygulamaktır:

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

1519410920' bu cevabında gösterildiği gibi WriteString yoluyla da uygulayabileceğimizi unutmayın, ancak bu durumda, cevabını önceden dönüştürmek gerekir. ToString[expr, InputForm] ile ilgili InputForm ifadesi .

7
cevap Alexey Popkov 2018-06-24 09:30:41
kaynak

sadece buna dahil olmak üzere paketlerimden birini arıyordum ve bu işin harikalarını tanımladığım bazı mesajlar buldum: Debug::<some name> . Varsayılan olarak, bunlar kapatılır, bu yüzden fazla yük üretmeyin. Ancak, kodumu onlarla çöp atabilirim ve biraz kodun nasıl davrandığını tam olarak anlamaya ihtiyacım olursa onları açabilirim.

6
cevap rcollyer 2010-11-18 07:32:09
kaynak

yerleşik scoping yapıları hakkında beni rahatsız eden şeylerden biri, yerel değişken tanımlarının tümünü aynı anda değerlendirmesidir, bu nedenle

gibi yazamazsınız
With[{a = 5, b = 2 * a},
    ...
]

bir süre önce bunu yapmanıza izin veren WithNest adlı bir makro buldum.

gibi bir şey yapmak zorunda kalmadan değişken bağlamaları yerel tutmanıza izin verdiği için kullanışlı buluyorum
Module[{a = 5,b},
    b = 2 * a;
    ...
]

sonunda, yapabildiğim en iyi yol bu, bağlamaların listesini tekrarlamayı kolaylaştırmak için özel bir sembol kullanarak yapıldı ve bu sembolü gizli tutmak için tanımı kendi paketine koydum. Belki birinin bu soruna daha basit bir çözümü vardır?

denemek isterseniz, aşağıdakileri Scoping.m adı verilen bir dosyaya koyun:

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[[email protected],body]]];

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

End[];

EndPackage[];
6
cevap DGrady 2011-04-17 10:42:17
kaynak

bu kod, seçimi yığın değişimine bir resim olarak yükleyen bir palet yapar. Windows'da, seçimin daha sadık bir şekilde oluşturulmasını sağlayan ekstra bir düğme sağlanır.

kodu bir dizüstü bilgisayar hücresine kopyalayın ve değerlendirin. Ardından paleti çıktıdan çıkarın ve Palettes -> Install Palette...

kullanarak yükleyin

onunla herhangi bir sorun varsa, burada bir yorum gönderin. Dizüstü bilgisayar sürümünü indirin burada .


Begin["SOUploader`"];

Global`palette = [email protected][{},

   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"],

      [email protected][]
      ]
     }],

   (* 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[

          [email protected][
            [email protected][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];
        [email protected]["image/png"];
        entity =
         JLink`JavaNew[
          "org.apache.commons.httpclient.methods.multipart.\
MultipartRequestEntity", {part}, [email protected][]];
        [email protected][entity];
        code = [email protected][method];
        response = [email protected][];
        ];

       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[
         [email protected][] /.
          r_RasterBox :>
           Block[{},
            Throw[Image[First[r], "Byte", ColorSpace -> "RGB"], tag] /;
              True];
         $Failed,
         tag
         ]
        ]
       ];
     )
   (* Init end *)
   ]

End[];
5
cevap Szabolcs 2016-02-13 05:08:34
kaynak

eminim ki bir sürü insan, bazı şeyleri çalıştırdıkları durumla karşılaştı, sadece programın sıkıştığını değil, aynı zamanda son 10 dakika boyunca kaydedilmedi!

Düzenle

bundan bir süre acı çektikten sonra, bir gün kodunun Mathematica kodundan otomatik kaydetme oluşturabileceğini öğrendim. Ben böyle otomatik kaydetme kullanarak var olduğunu düşünüyorum geçmişte bana çok yardımcı oldu ve her zaman olasılığının pek çok insanın yapabileceğinin farkında olmadığı bir şey olduğunu hissettim.

kullandığım orijinal kod altta. Yorumlar sayesinde sorunlu olduğunu öğrendim ve ScheduledTask kullanarak alternatif bir şekilde yapmak çok daha iyi (sadece Mathematica 8'de çalışacak).

Bunun için

kodu olabilir bu cevap dan Sjoerd C. de Vries bulundu (Burada kopyalamanın iyi olup olmadığından emin olmadığım için, yalnızca bir bağlantı olarak bırakıyorum.)


aşağıdaki çözüm Dynamic kullanıyor . Her 60 saniyede bir dizüstü bilgisayarı kurtaracak, ancak görünüşe göre sadece hücresi görünüyorsa . Sadece birkaç nedenden dolayı buradan ayrılıyorum. (ve Mathematica 6 ve 7 kullanıcıları için)

/Düzenle

bunu çözmek için bir dizüstü bilgisayarın başında bu kodu kullanıyorum:

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

bu işinizi her 60 saniyede bir kurtaracak.

Giriş işlenmeden önce kaydedildiğinden ve bazı dosyalar girişten daha fazla metin olduğundan NotebookAutoSave[] olarak tercih ediyorum.

başlangıçta burada buldum: http://en.wikipedia.org/wiki/Talk:Mathematica#Criticisms

bu satırı çalıştırdıktan sonra, dosyanızı kapatıp yeniden açsanız bile tasarrufun gerçekleşeceğini unutmayın (dinamik güncelleme etkinleştirildiğinde).

ayrıca, Mathematica de geri alma olmadığından, tüm içeriğinizi silmemeye dikkat edin, çünkü geri döndürülemez hale gelecektir (önlem olarak, bu kodu her bitmiş defterden kaldırıyorum)

4
cevap tsvikas 2017-05-23 14:47:23
kaynak

bu Alberto Di Lullo tarafından yazılmıştır (yığın taşması üzerinde görünmüyor).

CopyToClipboard , Mathematica 7 için (Mathematica 8'de yerleşik)

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

orijinal yazı: http://forums.wolfram.com/mathgroup/archive/2010/Jun/msg00148.html

sıradan ondalık biçimde panoya çok sayıda kopyalama için yararlı bu rutin bulduk. E. g. CopyToClipboard["123456789.12345"]

Cell[[email protected]] tırnakları düzgünce kaldırır.

4
cevap Chris Degnen 2012-01-02 17:09:22
kaynak

bu klavye kısayolunu SystemFiles/FrontEnd/TextResources/Windows/KeyEventTranslations.tr dosyasına eklemek için paketler geliştirirken gerçekten yararlı buluyorum.

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

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

her Packagename.m için sonraki test için bir PackagenameTest.nb dizüstü bilgisayar yapıyorum ve test defterinin ilk 2 hücresi başlatma hücreleri olarak ayarlandı. İlk hücrede

koydum
Needs["PackageManipulations`"]

çok yararlı yüklemek için PackageManipulations Leonid tarafından yazılmış kütüphane. Bu ikinci hücre 1519110920 içerir '

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

tüm gerçek paket yeniden yapmak. Not: ilk iki satır sadece Remove tüm semboller mümkün olduğunca temiz bağlamları tutmak istiyorum.

sonra bir paketi yazmak ve test etmek için iş akışı böyle bir şey haline gelir.

  1. değişiklikleri Packagename.m olarak kaydedin .
  2. PackagenameTest.nb gidin ve CTRL + ALT + i yapmak .

bu, başlatma hücrelerinin paketi yeniden yüklemesine neden olur ve bu da testi gerçek olarak basitleştirir.

3
cevap nixeagle 2017-05-23 15:18:01
kaynak

aşağıdaki işlev format[expr_] , bir sayfa

üzerinde yayılan mathematica ifadelerini biçimlendirilmemiş/biçimlendirmek için kullanılabilir
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 /@ [email protected] // StringJoin];
format[expr_] := indent[expr // InputForm // ToString, "[({", "])}", ";"];

(*    
format[[email protected][{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 /@ [email protected] // StringJoin]]
*)

ref: https://codegolf.stackexchange.com/questions/3088/indent-a-string-using-given-parentheses

1
cevap Prashant Bhate 2017-04-13 15:38:59
kaynak