Mathematica 도구 가방에 무엇입니까? [닫은]

우리 모두 Mathematica는 훌륭하지만 중요한 기능이 부족하다는 것도 알고 있습니다. Mathematica와 함께 어떤 종류의 외부 패키지 / 도구 / 리소스를 사용하십니까?

이 주요 게시물을 편집하여 과학 연구에 일반적으로 적용 할 수 있고 가능한 많은 사람들이 유용하다고 생각하는 자료를 포함하도록 다른 사람을 초대합니다. 작은 코드 스 니펫조차도 언제든지 기여할 수 있습니다 (타이밍 루틴을 위해 아래에서 한 것처럼).

또한 Mathematica 7 이상의 문서화되지 않은 유용한 기능은 사용자 자신을 발견하거나 일부 용지 / 사이트에서 발굴 된 문서를 가장 환영합니다.

왜 멋진 지 또는 어떤 유틸리티가 제공되는지에 대한 간단한 설명이나 의견을 포함하십시오. 제휴사 링크로 아마존 도서에 링크하는 경우 링크 뒤에 이름을 붙여서 언급하십시오.

패키지 :

1. LevelScheme좋은 음모를 꾸미는 Mathematica의 기능을 크게 확장 한 패키지입니다. 나는 프레임 / 축 틱에 대한 훨씬 개선 된 제어를 위해 다른 것을 위해 사용하지 않으면 사용합니다. 최신 버전 인 SciDraw가 올해 출시 될 예정입니다.
2. 데이비드 파크 Presentation Package(US $ 50-업데이트 비용 없음)
3. Jeremy Michelson의 grassmannOps패키지는 Grassmann 변수와 사소한 정류 관계가없는 연산자로 대수 및 미적분학을 수행하는 데 필요한 리소스를 제공합니다.
4. GrassmannAlgebraGrassmann 및 Clifford 대수와 함께 작업하기위한 John Brown의 패키지 및 책.
5. RISC (심볼 계산 연구소) 에는 Mathematica (및 기타 언어)를 다운로드 할 수있는 다양한 패키지가 있습니다. 특히 Algoithmic Combinatorics 그룹의 소프트웨어 페이지 에는 자동 정리 증명을위한 이론과 기호 요약, 차이 방정식 등을위한 다양한 패키지가 있습니다.

도구 :

1. MASHDaniel Reeves의 우수한 Perl 스크립트는 본질적으로 Mathematica v7에 대한 스크립팅 지원을 제공합니다. (이제 Mathematica 8부터 -script옵션이 내장되어 있습니다.)
2. alternate Mathematica shell하는 GNU readline에 입력이 (Python을 사용 유닉스 나 전용)
3. ColourMaths 패키지를 사용하면 표현의 일부를 시각적으로 선택하고 조작 할 수 있습니다. http://www.dbaileyconsultancy.co.uk/colour_maths/colour_maths.html

자원:

1. Wolfram의 자체 리포지토리 MathSource에는 다양한 응용 분야를위한 좁은 노트북이라면 많은 유용성이 있습니다. 또한 같은 다른 섹션을 확인하십시오

   • Current Documentation,
   • Courseware 강의를 위해
   • 그리고 Demos데모를 위해.

2. 티카 Wikibook .

서적:

1. Mathematica 프로그래밍 : Mathematica 에서 For 루프 이외의 작업을 수행하려는 경우 Leonid Shifrin ( web, pdf) 의 고급 소개 를 반드시 읽으십시오 . 우리는 여기서 스스로 질문에 답하는 것을 기쁘게 생각합니다.Leonid
2. 티카와 양자 방법 제임스 F. Feagin에 의해 ( 아마존 )
3. Stephen Wolfram 의 Mathematica Book ( 아마존 ) ( web)
4. 샴 개요 ( 아마존 )
5. Stan Wagon의 실제 Mathematica ( 아마존 )-600 페이지의 깔끔한 예가 Mathematica 버전 7로 올라갑니다. 시각화 기술이 특히 좋습니다 Demonstrations Page.
6. Richard Gaylord의 Mathematica Programming Fundamentals ( pdf) -Mathematica 프로그래밍에 대해 알아야 할 대부분의 정보를 간결하게 소개합니다.
7. Sal Mangano의 Mathematica Cookbook은 O'Reilly 2010 832쪽에 의해 출판했습니다. -잘 알려진 O'Reilly Cookbook 스타일로 작성 : 문제-솔루션. 중간체 용.
8. Mathematica와의 미분 방정식, 3rd Ed. Elsevier 2004 Amsterdam by Martha L. Abell, James P. Braselton-893 페이지 초보자는 DE와 Mathematica를 동시에 해결하는 방법을 배웁니다.

문서화되지 않은 (또는 거의 문서화되지 않은) 기능 :

7. Mathematica 키보드 단축키를 사용자 정의하는 방법. 참조하십시오 this question.
8. Mathematica의 자체 기능에 사용되는 패턴 및 기능을 검사하는 방법. 보다this answer
9. Mathematica에서 GraphPlots의 일관된 크기를 달성하는 방법은 무엇입니까? 참조하십시오 this question.
10. Mathematica로 문서와 프리젠 테이션을 제작하는 방법. 참조하십시오 this question.

나는 이것을 전에 언급 했지만 가장 유용한 도구는 다음 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 . 그러나 2 차 처리에 사용할 수 있습니다.

유틸리티의 예로서, Wannier90 과 작업 해 왔는데 , 공간적으로 종속적 인 Hamiltonian을 다음과 같이 각 라인이 매트릭스의 다른 요소 인 파일로 출력합니다.

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

이 목록을 행렬 집합으로 만들기 위해 동일한 좌표를 포함하는 모든 하위 목록을 수집하고 요소 정보를 규칙으로 바꿨습니다 (예 : {i, j}-> Re [Hij] + I Im [Hij]). 그런 다음 수집 된 규칙을 SparseArray하나의 라이너 로 모두 바꾸십시오 .

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

솔직히 이것은 스위스 스위스 군용 칼이며 복잡한 것을 매우 간단하게 만듭니다. 다른 도구는 대부분 도메인에 따라 다르므로 게시하지 않을 것입니다. 그러나 전부는 아니지만 대부분이 참조 SelectEquivalents됩니다.

편집 : GatherBy여러 수준의 표현을 가능한 한 간단하게 그룹화 할 수 없다는 점에서 완전히 모방하지는 않습니다 GatherBy. 그러나 Map내가 필요한 대부분의 경우 제대로 작동합니다.

예 : @Yaroslav Bulatov는 자체 포함 된 예를 요청했습니다. 내 연구에서 크게 단순화 된 것이 하나 있습니다. 평면에 점들이 있다고 가정 해 봅시다

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

일련의 대칭 연산으로 포인트 수를 줄이려고합니다. (호기심을 나타 내기 위해 각 점 의 작은 그룹 을 생성하고 있습니다.)이 예에서는 z 축을 중심으로 4 배 회전축을 사용하겠습니다.

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각 점에서 동일한 이미지를 생성 할 수 있으므로 여기에서 절대적으로 중요합니다. 원래는을 사용 Sort했지만 점이 대칭 축에있는 경우 해당 축을 중심으로 한 회전에서 변하지 않고 자체 이미지가 추가됩니다. 따라서 Union이러한 추가 이미지를 제거합니다. 또한 GatherBy동일한 결과를 얻을 수 있습니다.)이 경우 포인트는 이미 사용할 형식이지만 각 그룹의 대표 포인트 만 필요하며 카운트를 원합니다. 동등한 점의. 각 포인트를 변환 할 필요가 없으므로Identity두 번째 위치에서 기능. 세 번째 기능을 위해서는 조심해야합니다. 여기에 전달되는 첫 번째 인수는 회전에 따라 점의 이미지가 될 것입니다.이 점은 점에 대해 {0,0,0}4 개의 동일한 요소의 목록이며 사용하면 카운트를 버립니다. 그러나 두 번째 인수는 해당 태그가있는 모든 요소의 목록 일 뿐이므로를 포함합니다 {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]

그러나 최소한의 코드로 얼마나 복잡한 변환이 가능한지 쉽게 알 수 있습니다.

Mathematica 노트북 인터페이스의 장점 중 하나는 Mathematica 뿐만 아니라 모든 언어로 표현을 평가할 수 있다는 것 입니다. 간단한 예로서, 평가 를 위해 포함 된 표현식을 운영 체제 쉘에 전달 하는 새로운 쉘 입력 셀 유형을 작성하는 것을 고려 하십시오.

먼저 텍스트 명령의 평가를 외부 쉘에 위임하는 함수를 정의하십시오.

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

두 번째 주장은 필요하며 나중에 명백해질 이유로 무시됩니다. 다음으로 Shell 이라는 새로운 스타일을 만들고 싶습니다 .

1. 새 노트북을여십시오.
2. 스타일 시트 서식 / 편집 메뉴 항목을 선택하십시오 .
3. 대화 상자에서 스타일 이름 입력 옆에 : type을 입력하십시오 Shell.
4. 새 스타일 옆의 셀 괄호를 선택하십시오.
5. 셀 / 표현식 메뉴 항목을 선택하십시오.
6. 아래 주어진 6 단계 텍스트로 셀 표현식을 덮어 씁니다 .
7. 다시 한 번 메뉴 항목 Cell / Show Expression을 선택하십시오.
8. 대화 상자를 닫습니다.

6 단계 텍스트 로 다음 셀 표현식을 사용하십시오 .

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. 셀에 유효한 운영 체제 쉘 명령을 입력하십시오 (예 : Unix의 경우 'ls'또는 Windows의 경우 'dir').
4. Shift + Enter를 누릅니다.

이 정의 된 스타일을 중앙에 위치한 스타일 시트에 유지하는 것이 가장 좋습니다. 또한 DeclarePackage를shellEvaluate 사용하여 평가 기능 을 스텁으로 정의하는 것이 가장 좋습니다. in을init.m . 이 두 가지 활동에 대한 자세한 내용은이 답변의 범위를 벗어납니다.

이 기능을 사용하면 원하는 구문으로 입력식이 포함 된 전자 필기장을 만들 수 있습니다. 평가 기능은 순수 Mathematica로 작성하거나 평가의 일부 또는 전부를 외부 기관에 위임 할 수 있습니다. 같은 평가를 셀에 관련된 다른 고리가 있다는 것을 알고 있어야합니다 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[]평가되면 입력 셀이 삭제되고 내용을 쉘 명령으로 평가하는 새 입력 셀로 대체됩니다.

Todd Gayley (Wolfram Research)는 내장 함수를 임의의 코드로 "랩핑"할 수있는 멋진 해킹을 보냅니다. 이 유용한 도구를 공유해야한다고 생각합니다. 다음은 my에 대한 Todd의 답변입니다 question.

약간 흥미로운 (?) 역사 : 내장 함수 "래핑"에 대한 해킹 스타일은 1994 년 Robby Villegas와 I에 의해 발명되었습니다. 그때는. 그 이후로 많은 사람들이 여러 번 사용했습니다. 내부자의 트릭이지만 약간의 내장 함수 정의에 자신의 코드를 주입하는 표준적인 방법이되었다고 말하는 것이 공정하다고 생각합니다. 작업을 훌륭하게 수행합니다. 물론 $ inMsg 변수를 원하는 개인 컨텍스트에 넣을 수 있습니다.

Unprotect[Message];

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

Protect[Message];

이것은 완전한 리소스가 아니므로 여기에 답변 섹션에서 던지지 만 속도 문제를 알아낼 때 매우 유용하다는 것을 알았습니다 (불행히도 Mathematica 프로그래밍의 큰 부분입니다).

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

편집 : 여기 acl 의 버전이 있습니다 ( here ).

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]

Internal`InheritedBlock

나는 최근 공식 뉴스 그룹 의 Daniel Lichtblau의 메시지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!

매스 매 티카는 날카로운 도구이지만 그것의 다소 당신을 줄일 수 지정되지 않은 행동 과 눈사태 비밀의 진단 메시지 . 이를 처리하는 한 가지 방법은이 관용구에 따라 함수를 정의하는 것입니다.

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

그것은 많은 상용구이며, 나는 종종 건너 뛰고 싶어합니다. 특히 프로토 타입 제작시 Mathematica에서 많은 일이 발생합니다. 그래서 나는라는 매크로를 사용합니다.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. 이는 definecatch-all 오류 정의를 함수에 추가 하지 못하게 합니다.

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: ``";

제시된 구현은 업-값이나 카레를 지원하지 않으며 단순한 함수 정의보다 더 일반적인 패턴도 지원하지 않습니다. 그러나 여전히 유용합니다.

빈 노트를 열지 않고 시작

나는 Mathematica가 빈 노트북을 열어 놓고 시작하는 데 어려움을 겪었습니다. 이 노트북을 스크립트로 닫을 수는 있지만 여전히 잠깐 동안 깜박입니다. 내 해킹은 다음을 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[]
]

이제 Mathematica를 열어서 시작합니다 Invisible.nb

더 좋은 방법이있을 수 있지만 이것이 나에게 도움이되었습니다.

사용자 정의 Fold및FoldList

Fold[f, x] 에 해당 Fold[f, First@x, Rest@x]

덧붙여서, 이것이 향후 버전의 Mathematica로 들어갈 수 있다고 생각합니다.

놀라다! 현재 문서화되어 있지는 않지만 구현되었습니다. Oliver Ruebenkoenig에 의해 2011 년에 구현되었다는 소식을 들었습니다. 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]

이것을 허용하도록 업데이트되었습니다.

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

f[f[1 + 1, 2/2], 3^3]

"동적 파티션"

Mathematica.SE 포스트 # 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

세 번째 인수는 스플릿 사양 이외의 요소에 발생하는 사항을 제어합니다.

Szabolcs의 Mathematica 트릭

가장 자주 사용하는 것은 Paste Tabular Data Palette입니다.

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

최근 Daniel Lichtblau는 내가 본 적이없는이 방법을 보여주었습니다. 내 의견으로는 그것은 유틸리티를 크게 확장시킵니다.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.}  *)

일반적인 PDF / EMF 내보내기 문제 및 솔루션

1) 완전히 예상치 못한 문서화되지는 않았지만 Mathematica 는 화면에 노트북을 표시하는 데 사용되는 것과 다른 스타일 정의 세트를 사용하여 그래픽을 PDF 및 EPS 형식으로 내보내고 저장합니다. 기본적으로 노트북은 "작업"스타일 환경 ( ScreenStyleEvironment전역 $FrontEnd옵션의 기본값)에서 화면에 표시 되지만 "Printout"스타일 환경 ( PrintingStyleEnvironment전역 $FrontEnd옵션의 기본값) 에서 인쇄됩니다 . GIF 및 PNG와 같은 래스터 형식 또는 EMF 형식으로 그래픽을 내보내는 경우 Mathematica 그래픽을 는 노트북 내부와 똑같이 보이는 그래픽을 생성합니다. 것 같다 스타일 환경이 기본적으로 사용됩니다"Working"이 경우 스타일 환경이 렌더링에 사용됩니다. 그러나 PDF 또는 EPS 형식으로 무언가를 내보내거나 저장할 때는 그렇지 않습니다! 이 경우 "Printout""Working"스타일 환경과 매우 다릅니다. 우선, 스타일의 환경 설정 80 % . 둘째, 다른 스타일의 글꼴 크기에 대해 고유 한 값을 사용하므로 원래 화면 표시와 비교하여 생성 된 PDF 파일에서 글꼴 크기가 일관되지 않습니다. 후자 는 매우 성가신 FontSize 변동 이라고 할 수 있습니다 . 그러나 전역 옵션을 "작업 중" 으로 설정하면 이 문제를 피할 수 있습니다 ."Printout"MagnificationPrintingStyleEnvironment$FrontEnd

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

2) EMF 형식으로 내보내는 일반적인 문제는 대부분의 프로그램이 아니라 Mathematica 이 기본 크기로보기 좋지만 확대 할 때보기 흉한 파일을 생성한다는 것입니다. 메타 파일은 화면 해상도 충실도에서 샘플링 되기 때문 입니다. 생성 된 EMF 파일의 품질은 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]

이 파일을 Microsoft Word에 삽입하고 확대하면 첫 번째 "a"는 톱니가 있고 두 번째는 그렇지 않습니다 ( Mathematica 6으로 테스트 ).

Chris DegnenImageResolution 이 제안한 또 다른 방법 (이 옵션은 적어도 Mathematica 8 부터 시작됩니다 ).

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

3)에서 매스 매 티카 우리는 메타 파일로 그래픽을 변환하는 세 가지 방법이 있습니다를 통해 Export에 "EMF"강력하게 권장되는 방법을 (:를 통해, 최고의 품질로 메타 파일)을 생성 Save selection As...(메뉴 항목 정확한 그림 훨씬 덜 생산하고 , 권장되지 않음)를 통해 Edit ► Copy As ► Metafile메뉴 항목 ( 난 강력하게 추천 이 경로에 반대 ).

널리 사용되는 요구에 따라 SO API를 사용하여 상위 10 개의 SO 응답자 플롯 ( 주석 제외 ) 을 생성하는 코드 입니다.

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

캐싱 표현식

이 함수는 식을 캐시하는 데 매우 유용합니다. 이 두 함수의 흥미로운 점은 보유 식 자체가 해시 테이블 / 기호 Cache 또는 CacheIndex의 키로 사용되며, 함수가 f와 같이 정의 된 경우 결과 만 캐시 할 수있는 수학에서 잘 알려진 메모와 비교되는 것입니다. [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}를 평가하는 것이 훨씬 빠릅니다.

지역화 된 캐시를 갖기 위해 이러한 기능의 변형에 대해서는 (즉, 캐시 메모리가 자동으로 블록 구성 외부로 해제 됨)이 게시물을 참조하십시오. 보간에 반복 방지 호출

캐시 된 값 삭제

함수의 정의 수를 모르는 경우 캐시 된 값을 삭제합니다. 나는 정의가 논쟁의 어딘가에 공백이 있다고 생각합니다.

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

함수의 정의 수를 알고있을 때 캐시 된 값을 삭제합니다 (약간 빨라짐).

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

이것은 함수의 정의가 DownValues ​​목록의 끝에 있고 캐시 된 값은 이전에 있다는 사실을 사용합니다.

기호를 사용하여 데이터 및 객체와 유사한 기능 저장

또한 객체와 같은 기호를 사용하는 흥미로운 기능이 있습니다.

이미 데이터를 기호에 저장하고 DownValues를 사용하여 빠르게 액세스 할 수 있다는 것은 이미 잘 알려져 있습니다.

mysymbol["property"]=2;

이 사이트의 게시물에 제출 된 Dreeves에 따라 다음 기능을 사용하여 심볼의 키 (또는 속성) 목록에 액세스 할 수 있습니다.

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

이 함수를 많이 사용하여 심볼의 DownValues에 포함 된 모든 정보를 표시합니다.

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

마지막으로 객체 지향 프로그래밍에서 객체처럼 동작하는 기호를 만드는 간단한 방법이 있습니다 (OOP의 가장 기본적인 동작을 재현하지만 구문은 우아합니다).

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

속성은 반환 된 모듈에 의해 생성 된 심볼에서 지연된 값으로 DownValues ​​및 메서드로 저장됩니다. Mathematica의 Tree 데이터 구조에서 함수에 대한 일반적인 OO 구문 인 function2의 구문을 찾았습니다. .

각 기호에있는 기존 유형의 값 목록은 http://reference.wolfram.com/mathematica/tutorial/PatternsAndTransformationRules.html 및 http://www.verbeia.com/mathematica/tips/HTMLLinks/Tricks_Misc_4.html을 참조하십시오 . .

예를 들어 이것을 시도하십시오

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

http://library.wolfram.com/infocenter/MathSource/671/에있는 InheritRules라는 패키지를 사용하여 객체 상속을 에뮬레이션하려는 경우 계속 진행할 수 있습니다.

함수 정의를 newObject가 아닌 유형 기호에 저장할 수도 있습니다. 따라서 NewObject가 newObject 대신 type [newObject]를 반환하면 NewObject 외부 (이 아닌 내부)와 같은 함수와 function2를 정의 할 수 있으며 이전과 동일한 사용법을 가질 수 있습니다 .

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

함수 및 함수 2가 유형 기호에 정의되어 있는지 확인하려면 UpValues ​​[type]을 사용하십시오.

이 마지막 구문에 대한 추가 아이디어는 https://mathematica.stackexchange.com/a/999/66에 소개되어 있습니다 .

SelectEquivalents의 개선 된 버전

@rcollyer : SelectEquivalents를 표면에 가져와 주셔서 감사합니다. 놀라운 기능입니다. 더 많은 가능성과 옵션을 사용하여 위에 나열된 SelectEquivalents의 개선 된 버전은 다음과 같습니다.

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

이 버전을 사용하는 방법에 대한 예는 다음과 같습니다.

Mathematica 수집 / 수집을 올바르게 사용하기

Mathematica에서 피벗 테이블 함수를 어떻게 수행 하시겠습니까?

Mathematica 빠른 2D 비닝 알고리즘

내부 가방

Daniel Lichtblau는 여기서 목록을 확장하기위한 흥미로운 내부 데이터 구조를 설명합니다.

Mathematica에서 쿼드 트리 구현

디버깅 기능

이 두 게시물은 디버깅에 유용한 기능을 나타냅니다.

Mathematica를 사용하여 작거나 큰 코드를 작성할 때 디버깅하는 방법은 무엇입니까? 작업대? mma 디버거? 또는 다른 것? (보여)

/programming/5459735/the-clearest-way-to-represent-mathematicas-evaluation-sequence/5527117#5527117 (TraceView)

다음은 Reap 및 Sow를 기반으로 프로그램의 다른 부분에서 표현식을 추출하여 심볼에 저장하는 또 다른 함수입니다.

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

기타 자료

학습 목적을위한 흥미로운 링크 목록은 다음과 같습니다.

Mathematica 학습 자료 모음

여기에 업데이트 : https://mathematica.stackexchange.com/a/259/66

내 유틸리티 기능 (문제에 언급 된 MASH에 내장되어 있음) :

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

내가 사용한 한 가지 트릭은 대부분의 내장 함수가 잘못된 인수로 메시지를 보낸 다음 평가되지 않은 전체 양식을 반환하여 잘못된 인수로 작동하는 방식을 에뮬레이션 할 수있게 해줍니다 Condition. foo하나의 인수로만 작동해야하는 경우 :

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

더 복잡한 요구가있는 경우 인수 유효성 검증 및 메시지 생성을 독립 함수로 쉽게 고려할 수 있습니다. Condition메시지를 생성 하는 것 이상으로 부작용을 사용하여 더 정교한 작업을 수행 할 수 있지만 제 생각에는 대부분 "매끄러운 해킹"범주에 속하며 가능한 경우 피해야합니다.

또한 "메타 프로그래밍"범주에서 Mathematica 패키지 ( .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]]

컨텍스트가없는 인쇄 시스템 기호 정의

contextFreeDefinition[]기능은 아래의 앞에 추가하는 가장 일반적인 맥락없이 심볼의 정의를 인쇄하려고합니다. 그런 다음 정의를 Workbench에 복사하고 가독성을 위해 형식화 할 수 있습니다 (선택, 마우스 오른쪽 단추를 클릭하고 소스-> 형식)

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
]

앤티 앨리어싱 3D 그래픽

그래픽 하드웨어가 기본적으로 지원하지 않더라도 3D 그래픽을 앤티 앨리어싱하는 매우 간단한 기술입니다.

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

예를 들면 다음과 같습니다.

값이 크 n거나 이미지 크기가 크면 그래픽 드라이버 버그가 발생하거나 인공물이 생길 수 있습니다.

노트북 차이 기능

노트북 diff 기능은 <<AuthorTools`패키지 및 문서화되지 않은 NotebookTools`컨텍스트 ( 버전 8 이상)에서 사용할 수 있습니다 . 이것은 현재 열려있는 두 개의 노트북을 비교하기위한 작은 GUI입니다.

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

재귀 적 순수 함수 ( #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], ...구성 요소의 새로운 "루트"가 발견 될 때마다 메모 된 값이 수정 되는 방식으로 메모를 설정합니다 . 이로 인해 상당한 속도가 향상됩니다. 우리는 할당을 사용하기 때문에 HoldAll이 필요합니다.이 구문은 더 모호하고 매력적입니다). 이 기능은 Fred Simons, Szabolcs Horvat, DrMajorBob 및 여러분과 관련된 온라인 및 오프라인 Mathgroup 토론의 결과입니다. 예:

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

내장보다 확실히 느리지 만 코드 크기의 경우 여전히 IMO가 매우 빠릅니다.

또 다른 예는 다음과 같습니다 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}} 

이것은 Stan Wagon의 저서에서 나온 레시피입니다. 정확도 부족으로 인해 내장 플롯이 잘못 작동 할 때 사용하십시오

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

Mathematica의 가치 하락에서 "사전 같은"행동이 필요할 때 종종 Kristjan Kannike의 다음 트릭을 사용합니다.

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

이 문서화되지 않은 사용하여 배치 모드에서 MathKernel을 실행할 수 있는 명령 줄 옵션 -batchinput과-batchoutput :

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

(여기서 input.m줄 바꾸기 문자로 끝나는 배치 입력 파일 outputfile.txt은 출력이 리디렉션 될 파일입니다).

에 티카 . V> = 6 MathKernel은 문서화되지 않은 명령 줄 옵션이 있습니다 :

-noicon

MathKernel의 작업 표시 줄에 아이콘이 표시되는지 여부를 제어합니다 (적어도 Windows에서는).

FrontEnd (최소 v.5 이상)에는 문서화되지 않은 명령 줄 옵션이 있습니다.

-b

스플래시 화면을 비활성화하고 Mathematica FrontEnd를 훨씬 빠르게 실행할 수 있습니다.

옵션

-directlaunch

가장 최근에 실행되는 메커니즘 을 비활성화합니다.시스템 레지스트리에서 .nb 파일과 관련된 버전을 시작하는 대신 설치된 Mathematica 버전.

이 작업을 수행하는 다른 방법 입니다 :

설치 디렉토리에서 Mathematica.exe 바이너리를 시작하는 대신 SystemFiles \ FrontEnd \ Binaries \ Windows에서 Mathematica.exe 바이너리를 실행하십시오. 전자는 간단한 런처 프로그램으로, 노트북 열기 요청을 사용자 인터페이스 사본을 실행하도록 재지 정하는 것이 가장 어렵습니다. 후자는 사용자 인터페이스 바이너리 자체입니다.

마지막 명령 줄 옵션과 전역 프런트 엔드 옵션 설정을 결합하여 설치된 VersionedPreferences->True 다른 Mathematica 버전 간에 환경 설정 공유를 비활성화 할 수 있습니다 .

SetOptions[$FrontEnd, VersionedPreferences -> True]

(위의 최신 Mathematica 버전 에서 평가해야합니다 .)

Mathematica 8 에서는 시스템 창의 환경 설정 대화 상자에서 "버전 별 프런트 엔드 환경 설정 생성 및 유지 관리"설정에서 제어됩니다 .

문서화되지 않은 키 -h(Windows 용 코드)를 사용하여 FrontEnd의 명령 줄 옵션 목록을 불완전하게 얻을 수 있습니다 .

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

MathKernel과 FrontEnd에 유용한 다른 명령 줄 옵션이 있습니까? 알고 있다면 공유하십시오.

관련 질문 .

내가 가장 좋아하는 핵은 작은 코드 생성 매크로로, 표준 상용구 명령을 짧은 명령 하나로 대체 할 수 있습니다. 또는 전자 필기장 열기 / 작성을위한 명령을 만들 수 있습니다.

일상적인 Mathematica 워크 플로에서 한동안 사용해온 내용은 ​​다음과 같습니다. 나는 다음을 많이 수행하는 것을 발견했다.

1. 노트북에 비공개 컨텍스트를 만들고 필요한 패키지를로드 한 후 자동 저장하십시오.
2. 이 노트북으로 잠시 작업 한 후, "메인"노트북에서 사용한 정의에 액세스하면서 자체 개인 컨텍스트를 사용하여 별도의 노트북에서 스크래치 계산을 수행하고 싶습니다. 개인 컨텍스트를 설정 했으므로 $ ContextPath를 수동으로 조정해야합니다.

이 모든 것을 손으로 반복해서하는 것은 고통이므로 자동화합시다! 먼저, 일부 유틸리티 코드 :

(* 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있지만 독자에게 연습으로 남겨 두겠습니다.

PageWidth-> 무한대로 PutAppend

에 티카 의 사용 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}