[resources] 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에는 다양한 응용 분야를위한 좁은 노트북이라면 많은 유용성이 있습니다. 또한 같은 다른 섹션을 확인하십시오

  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를 동시에 해결하는 방법을 배웁니다.

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

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


답변

나는 이것을 전에 언급 했지만 가장 유용한 도구는 다음 ReapSow같은 동작을 모방 / 확장 하는 응용 프로그램 입니다 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합니다.

편집 : 씨 마법사가 멀리 않는 간단한 버전을 제공하고 있습니다 ThrowCatch및 구문 분석에 좀 더 쉽게입니다 :

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

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


사용자 정의 FoldFoldList

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