Myślę, że to, co myli większość użytkowników, którzy są nowi w pakietach, to większe pytanie, gdzie je umieścić i jak z nich korzystać. Omówię to w szerszym kontekście.

Załóżmy, że pracujesz nad jakimś znaczącym lub rozszerzonym tematem, który nazwiemy TopicX. Temat ten może obejmować wiele różnego rodzaju notatników i kilka pakietów, a być może późniejszą dokumentację pacleta w stylu WRI.

Najpierw musisz mieć miejsce, aby zebrać wszystkie swoje prace na TopicX. "The best place" aby go zebrać, należy umieścić go w folderze TopicX w folderze prywatne aplikacje. Możesz znaleźć ten folder aplikacji, oceniając $UserBaseDirectory w Mathematica , a następnie poszukując istniejącego folderu aplikacji. Wielu użytkowników znajduje powód, aby umieścić swoje aplikacje gdzie indziej, ale myślę, że jest to najlepsza i standardowa Lokalizacja z wielu powodów, których Nie będę tutaj opisywał.

W folderze TopicX można zbudować strukturę folderów dla własnych notebooków i innych pliki związane z tematem, zgodnie z własnymi preferencjami. Jak na razie nie ma paczki.

Podczas pracy nad tym tematem będziesz mógł rozwijać różne procedury związane z projektem. Możesz je rozwinąć w odpowiednim notatniku, a następnie przenieść je do sekcji procedur na górze notatnika. Możesz zostawić tam rutynę na chwilę, a nawet skopiować ją z notatnika do notatnika, dopóki nie będziesz zadowolony, że działa poprawnie. Często nazywam to "paczkowym czyśćcem". Dla tych procedur napisz komunikaty użytkowania, SyntaxInformation Instrukcja, Attributes jeśli istnieją, Options definicje jeśli istnieją, komunikaty błędów, jeśli procedura sprawdza błędy. Jeśli to wszystko zostanie zrobione, rutyna jest gotowa do "nieba pakietu".

Aplikacja może mieć więcej niż jeden pakiet związany z nim. Mam zamiar założyć, że tak jest, lub przyszłą możliwość, i podać nazwy pakietów inne niż TopicX. Załóżmy więc, że twój pierwszy pakiet będzie nosił nazwę Package1. W folderze TopicX utwórz nowy plik o nazwie Package1.m. Możesz to zrobić otwierając Mathematica , używając Create New> Other> Package, a następnie zapisując plik jako Package1.m w folderze TopicX.

Pliki pakietów mogą mieć organizację przekrojową tak jak zwykłe Notebooki. Możesz utworzyć organizację sekcyjną dla wiadomości BeginPackage i Usage, dla sekcji prywatnej i dla sekcji końcowej. Możesz również chcieć podrozdziałów dla poszczególnych procedur. Według Twojego gustu. Pliki pakietów może również zawierać komórki tekstowe do adnotacji lub notatek.

Rzeczywisty Mathematica kod w pliku pakietu jest zawarty w komórkach kodu. Są to komórki automatycznie Inicjalizujące i są oceniane podczas ładowania pakietu. Komórki, które mają styl wprowadzania, nie są częścią pakietu. (Konwersja komórki kodu na komórkę wejściową jest sposobem na zapisanie starej wersji procedury.) Możesz skopiować swoje procedury z notatnika, w którym zostały opracowane do pliku pakietu. Użycie Wiadomości do sekcji użycie i kod do sekcji prywatnej. W zależności od sposobu kopiowania może być konieczne przełączenie komórek wejściowych na komórki kodu za pomocą menu stylu kontekstowego. Komórki kodu, zwłaszcza wiadomości o użytkowaniu, często nie pękają wygodnie i wymagają poziomego przewijania. Czasami pomaga tymczasowo przełączyć je na komórki wejściowe do edycji.

Po strukturze folderów, Instrukcja BeginPackage będzie następująca:

BeginPackage["TopicX`Package1`"]

I pakiet może być załadowany z dowolnego miejsca z:

<< TopicX`Package1`

Jest jednak jeszcze jedna bardzo wygodna funkcja, którą zaimplementował WRI. Jeśli użytkownik wykona instrukcję load bez nazwy pakietu w następujący sposób:

<< TopicX`

Następnie Mathematica szuka pliku init.m w folderze TopicX/Kernel i ocenia go. Utwórz folder jądra w TopicX i plik init.m w nim i dołącz instrukcje:

Get["TopicX`Package1`"]
Get["TopicX`Package2`"]  

Jeśli w aplikacji znajdują się inne pakiety.

To jest to. Nie będę. omów szczegóły kodu pakietu, ponieważ jest to dość dobrze omówione gdzie indziej.

Później, jeśli chcesz dodać dokumentację WRI paclet, możesz uzyskać Wolfram Workbench. Możesz po prostu przenieść pliki pakietów do Workbench i zacząć pisać strony przewodnika i funkcji. Jedną ważną rzeczą do zapamiętania jest to, że wszystkie procedury ze wszystkich pakietów w TopicX są zawarte w jednym pakiecie dokumentacji dla TopicX.

[[2]}będziesz chciał przynajmniej spojrzeć na rozdziały 1-2 Romana Maedera Programowanie w Mathematica na początek. To było przejście, którego użyłem, gdy zaczynałem od pisania pakietów.

W szczególności książka zawiera listę pliku pakietu szablonów o nazwie Skeleton.m. Oto jak to wygląda:

(* :Title: Skeleton.m -- a package template *)

(* :Context: ProgrammingInMathematica`Skeleton` *)

(* :Author: Roman E. Maeder *)

(* :Summary:
   The skeleton package is a syntactically correct framework for package
   development.
 *)

(* :Copyright: © <year> by <name or institution> *)

(* :Package Version: 2.0 *)

(* :Mathematica Version: 3.0 *)

(* :History:
   2.0 for Programming in Mathematica, 3rd ed.
   1.1 for Programming in Mathematica, 2nd ed.
   1.0 for Programming in Mathematica, 1st ed.
*)

(* :Keywords: template, skeleton, package *)

(* :Sources:
   Roman E. Maeder. Programming in Mathematica, 3rd ed. Addison-Wesley, 1996.
*)

(* :Warnings:
   <description of global effects, incompatibilities>
*)

(* :Limitations:
   <special cases not handled, known problems>
*)

(* :Discussion:
   <description of algorithm, information for experts>
*)

(* :Requirements:
   ProgrammingInMathematica/Package1.m
   ProgrammingInMathematica/Package2.m
   ProgrammingInMathematica/Package3.m
*)

(* :Examples:
   <sample input that demonstrates the features of this package>
*)


(* set up the package context, including public imports *)

BeginPackage["ProgrammingInMathematica`Skeleton`", "ProgrammingInMathematica`Package1`", "ProgrammingInMathematica`Package2`"]

(* usage messages for the exported functions and the context itself *)

Skeleton::usage = "Skeleton.m is a package that does nothing."

Function1::usage = "Function1[n] does nothing."
Function2::usage = "Function2[n, (m : 17)] does even more nothing."

(* error messages for the exported objects *)

Skeleton::badarg = "You twit, you called `1` with argument `2`!"

Begin["`Private`"]    (* begin the private context (implementation part) *)

Needs["ProgrammingInMathematica`Package3`"]    (* read in any hidden imports *)

(* unprotect any system functions for which definitions will be made *)

protected = Unprotect[ Sin, Cos ]

(* definition of auxiliary functions and local (static) variables *)

Aux[f_] := Do[something]

staticvar = 0

(* definition of the exported functions *)

Function1[n_] := n

Function2[n_, m_ : 17] := n m /; n < 5 || Message[Skeleton::badarg, Function2, n]

(* definitions for system functions *)

Sin /: Sin[x_]^2 := 1 - Cos[x]^2

Protect[ Evaluate[protected] ]     (* restore protection of system symbols *)

End[ ]         (* end the private context *)

Protect[ Function1, Function2 ]    (* protect exported symbols *)

EndPackage[ ]  (* end the package context *)

Dla własnego pakietu, po prostu zmodyfikuj, Zamień i/lub usuń rzeczy z szablonu w razie potrzeby.

Kolejna rzecz, która nie jest jasna z dokumentacji. Jeśli chcesz zrobić .plik m z .plik nb, przed zapisaniem musisz zmienić właściwości komórki czegokolwiek, co chcesz w nim umieścić na Komórka Inicjalizacyjna . W przeciwnym razie zapisany plik modułu nie będzie miał aktywnej zawartości!

Dla mnie najlepszy sposób tworzenia pakietów w oparciu o książkę Maedera. To robi rzeczy szybko i pół ... Brudno(!) tak, że usages działa dobrze, ale nie ma fantazyjne wpisy Centrum Dokumentacji. Sposób na stworzenie takiego (całkowicie dok. pakiet kompatybilny z Centrum jest fachowo pokryty tutaj .

Do pytania pod ręką ...

Jeśli uważasz, że musisz oddzielić funkcjonalność, to jedno podejście jest (jako szablon)

BeginPackage["YourPackageDirectory`YourPackageName`", {"YourPackagesDependencys`"}];
(* usages go here *)
Begin ["Private`"];
(* Function definitions go here *)
End[]; (* private *)
(* protect what you want *)
EndPackage[];

Więc czego możesz chcieć to do with your wrapper package is

BeginPackage[`Lopez`SimpleArithmetic`", {"Lopez`Addition`", "Lopez`Multiplication`"}];
Begin["`Private`"];
End[];
EndPackage[];

Wtedy uruchamiasz inny pakiet jak

BeginPackage["Lopez`Addition`"];
AddTwo::usage = "AddTwo[a, b] returns a+b";
AddThree::usage = "AddTwo[a, b, c] returns a+b+c";
Begin["`Private`"];
AddTwo[a_, b_] := a + b;
AddThree[a_, b_, c_] := a + b + c;
End[];
EndPackage[];

I trzeci w podobnej linii o nazwie Lopez`Multiplication. Wszystkie pakiety żyją w $UserAddOnsDirectory/Lopez, które prawdopodobnie będziesz musiał utworzyć.

Używasz ich ładując Lopez`SimpleArithmetic (Needs["Lopez`SimpleArithmetic`"]), ale można również załadować poszczególne pakiety do debugowania.

Jako kolejny przewodnik sugerowałbym studiowanie kodu źródłowego w dziedzictwie statystyk jako skomplikowanego pakietu z wieloma zależnościami, które zostały bezproblemowo rozwiązane kiedy ładujesz rzeczy. Przebieg może się różnić.

D.

Szybki Start tutorial

Jest to krótki przewodnik po Jak skonfigurować pakiet zgodnie z typową strukturą. Nie wyjaśnia dlaczego jest to zwykle robione w ten sposób, i nie omawia innego możliwego sposobu, aby to zrobić. To pozostawia się do innych odpowiedzi tutaj (zwłaszcza Leonida), a także oficjalnej dokumentacji.

Postępuj zgodnie z tym przewodnikiem, aby szybko skonfigurować swój pierwszy pakiet, aby mieć coś konkretnego do eksperymentowania. Potem ty musi przeczytać Pozostałe odpowiedzi i odniesienia poniżej, aby uzyskać pełniejsze zrozumienie.

Co to jest pakiet?

Jest to plik tekstowy z rozszerzeniem .m (lub .wl), który zawiera definicje funkcji i przestrzega pewnych konwencji. Można go załadować za pomocą Needs lub Get udostępnienie funkcji do użytku.

Jak utworzyć pakiet podstawowy?

Pakiet podstawowy składa się z jednego pliku. Bardziej złożone, Pakiety wielotematyczne nie będą tutaj omawiane.

1. Wybierz nazwę pakietu. W tym przykładzie przyjmę nazwę MyPack.

2. Wpisz kod źródłowy do pliku o nazwie MyPack.m.

3. Plik musi mieć następującą strukturę:

   BeginPackage["MyPack`"];
   
   (* Export section *)
   
   (* Every function that the package provides will have a usage message here. *)
   (* There will be no function definitions in this section, only usage messages. *)
   (* Public functions will have names starting with capitals, by convention. *)
   
   MyFunction::usage = "MyFunction[x]";
   
   Begin["`Private`"]; (* note ` character both before and after Private *)
   
   (* Implementation section *)
   
   (* Function definitions will go into this section *)
   
   MyFunction[x_] := helper[x]
   
   (* All functions which are not public, and are only used in the 
      internal implementation of the package, go into this section.
      These have non-capital names by convention. *)
   
   helper[z_] := z^2
   
   End[]; (* `Private` *)
   
   EndPackage[]; (* MyPack` *)
   

4. Plik musi być umieszczony w katalogu, który znajduje się w $Path.

   Pakiety są zazwyczaj instalowane w FileNameJoin[{$UserBaseDirectory, "Applications"}]

Jak załadować i użyć paczki?

Oceń

<< MyPack`

Jeśli MyPack.m jest w $Path, będzie załadowany.

Teraz Funkcja MyFunction jest dostępna do użycia.

Referencje

• Tworzenie Pakietów Językowych Wolfram (Dokumentacja)

• Modułowość i nazewnictwo rzeczy (dokumentacja). Odczyt z "kontekstów" do "plików dla pakietów".

• Pakiet organizacja

Uwagi

^{Opis W tym przewodniku jest celowo uproszczony, aby ułatwić jego przestrzeganie. Kiedy stwierdzałem rzeczy w kategoriach absolutnych, trochę "kłamałem" tu i ówdzie: nie musisz ściśle podążać za tą dokładną strukturą. Jednak struktura ta reprezentuje najlepsze praktyki, a wyjście poza nią wymaga zrozumienia kontekstów {29]}. Pozostałe odpowiedzi tutaj należy uznać za wymagane czytanie po skonfigurowaniu pierwszego pakietu.}

Użytecznym rozwiązaniem może być użycie warsztatu Wolfram, jeśli masz do niego dostęp. Niezależnie od tego, czy używasz Workbencha, czy nie, dobrym sposobem zorganizowania aplikacji jest posiadanie nadrzędnego pakietu, który wywołuje Pakiety podrzędne. Na przykład, w dużym projekcie, który obecnie opracowuję, jest pakiet dla ogólnych narzędzi (masowanie danych), pakiet dla głównych funkcji kreślenia (wysoce dostosowana wersja zwykłych) i pakiet, który zapewnia bardziej ogólną wersję oprogramowania. jedną z funkcji kreślarskich (DateListBarChart). Pakiet ogólny wywołuje dwa pierwsze z nich, a pakiet ogólny i drugi wywołują trzeci. Pakiet ogólny może być tak prosty, jak poniżej. W rzeczywistości ten jest głównym pakietem dla mojej aplikacji, z akronimem dla mojego pracodawcy zmienionym na XYZ.

(* Mathematica Package *)
(* Created by the Wolfram Workbench May 20, 2010 *)
BeginPackage["XYZ`" ,{"XYZ`DateListBarChart`","XYZ`XYZGraphs`","XYZ`XYZUtilities`"}]
 (* Exported symbols added here with SymbolName::usage *) 
Begin["`Private`"]
 (* Implementation of the package *)
End[]
EndPackage[]

Sposób organizacji tych (do wdrożenia) to, przynajmniej na Mac OS X, umieszczenie ich w /Users/username/Library/Mathematica/Applications/. Wewnątrz znajduje się folder z nazwą głównej aplikacji (np. XYZ), zawierający pakiet główny, XYZ.m oraz wszelkie pakiety pomocnicze. Dokumentacja i jądro są podfolderami tego folderu.

Możesz znaleźć kilka przydatnych wskazówek w białej księdze Wolframa na temat dużych projektów, dostępnej na tej stronie .

Lubię używać wtyczki Mathematica dla Eclipse (lub Workbench) do rozwoju. Tworzenie pakietów jest bardzo proste, możesz napisać dokumentację dla swoich funkcji (a także przewodniki i samouczki) i wdrożyć swój pakiet do instalacji Mathematica, aby zarówno funkcje, jak i dokumentacja były zintegrowane z wbudowanymi.

To działa bardzo ładnie(i to samo dla webMathematica, jeśli jesteś zainteresowany).

Istnieje niezwykle ładny samouczek" Building Packages: a basic tutorial " autorstwa Davida Reissa (Scientific Arts).

Jest w formacie Notatnika, a link do niego można znaleźć na http://community.wolfram.com/groups/-/m/t/214901