KDP_book

Mathematica: Functional and procedural programming

return of the full path to the copied file/directory. If the copied file already exists, it isn't updated if the target directory already exists, the x directory is copied into its subdirectory of the same name. The fragment presents source code of the CopyFileToDir procedure with some typical examples of its application:

In[5]:= CopyFileToDir[x_ /; PathToFileQ[x], y_ /; DirQ[y]] := Module[{a, b}, If[DirQ[x], CopyDir[x, y], If[FileExistsQ[x],

a = FileNameSplit[x][[–1]]; If[FileExistsQ[b = y <> "\\" <> a], b, CopyFile[x, b]], $Failed]]]

In[6]:= CopyFileToDir["c:/math/book_2020.doc", Directory[]]

Out[6]= "C:\\Users\\Aladjev\\Documents\\book_2020.doc"

In[7]:= CopyFileToDir["C:\\Temp", "E:\\Temp"]

Out[7]= "E:\\Temp\\Temp"

The CopyFileToDir procedure has a variety of appendices in processing problems of file system of the computer.

In conclusion of the section an useful enough procedure is represented which provides only two functions – (1) obtaining of the list of attributes ascribed to a file or directory, and (2) the removal of all ascribed attributes. The call Attribs[x] returns the list of attributes in string format which are ascribed to a file or a directory x. On the main directories of volumes of direct access the procedure call Attribs returns $Failed, while the procedure call Attribs[x, y] with the 2nd optional y argument – an arbitrary expression – deletes all attributes which are ascribed to a file or a directory x with returning 0 at a successful call. The following fragment represents source code of the Attribs procedure with the most typical examples of its application:

In[3330]:= Attribs[x_ /; FileExistsQ[x] || DirectoryQ[x], y___] := Module[{b, a = StandPath[x], d = ToString[Unique["g"]], c = "attrib.exe", g},

If[DirQ[x] && StringLength[x] == 3 && StringTake[x, {2, 2}] == ":", $Failed, g[] := Quiet[DeleteFile[Directory[] <> "\\" <> c]]; If[! FileExistsQ[c], LoadExtProg[c]];

If[{y} == {}, Run[c <> " " <> a <> " > ", d]; g[]; b = Characters[StringReplace[StringTake[Read[d, String], {1, –StringLength[a] – 1}], " " –> ""]]; DeleteFile[Close[d]]; b,

321

V.Z. Aladjev, M.L. Shishakov, V.A. Vaganov

a = Run[c <> " –A –H –R –S " <> a]; g[]; a]]]

In[3331]:= Map[Attribs, {"c:\\", "e:/", "c:/tm", "c:/tm/bu.doc"}]

Out[3331]= {$Failed, $Failed, {"A"}, {"A", "R", "S"}} In[3332]:= Attribs["c:/tm/bu.doc", 77]

Out[3332]= 0

In[3333]:= Attribs["c:/tm/bu.doc"]

Out[3333]= {}

Note, that as x argument the usage of an existing file, full path to a file or a directory is supposed. At the same time, the file "attrib.exe" is removed from the directory defined by the call Directory[] after a procedure call. The Attribs procedure is rather fast–acting, supplementing procedures Attrib, Attrib1. The Attribs procedure is effectively applied in programming of means of access to elements of file system of the computer at processing their attributes. Thus, it should be noted once again that the Mathematica has no means for processing of attributes of files and directories therefore the offered procedures Attrib, Attrib1 and Attribs in a certain measure fill this niche.

So, the declared possibility of extension of the Mathematica directories that is determined by the $Path variable, generally doesn't operate already concerning the external commands of MS DOS what well illustrates both consideration of the above procedures Attrib, LoadExtProg and Attrib1, and an example with the external "tasklist" command which is provided display of all active processes of the current session with Windows 7:

In[2565]:= Run["tasklist", " > ", "C:\\Temp\\tasklist.txt"]

Out[2565]= 1

In[2566]:= LoadExtProg["tasklist.exe"];

Run["tasklist" <> " > " <> "C:\\Temp\\tasklist.txt"]

Out[2566]= 0

:System Idle Process

:0

:Services

:0

===============

:Skype.exe

:2396

322

Mathematica: Functional and procedural programming

:Console

:1

===============

:Mathematica.exe

:4120

:Console

:1

:WolframKernel.exe

:5888

:Console

:1

===============

The first example of the previous fragment illustrates that attempt by means of the Run to execute the external command "tasklist" of DOS completes unsuccessfully (return code 1), while result of the call LoadExtProg["tasklist.exe"] with search and upload into the directory defined by the call Directory[] of the "tasklist.exe" file, allows to successfully execute by means of the Run function the external command "tasklist" with preserving of result of its performance in file of txt-format whose contents is represented by the shaded area. Meanwhile, use of external software on the basis of the Run function along with possibility of extension of functionality of the Mathematica causes a rather serious portability question. So, the means developed by means of this method with use of the external commands of MS DOS are subject to influence of variability of the commands of DOS depending on version of basic operating system. In a number of cases it demands a certain adaptation of the software according to the basic operating system.

4.4. Additional tools for files and directories processing of file system of the computer

This item presents tools of files and directories processing of file system of the computer which supplement and in certain cases also extend the above means. Unlike the DeleteDirectory and DeleteFile functions the DelDirFile1 procedure removes a directory or file from file system of the computer.

323

V.Z. Aladjev, M.L. Shishakov, V.A. Vaganov

Similarly to functions DeleteFile and DeleteDirectory, the call DelDirFile[w] removes from file system of the computer a file or directory w, returning Null, i.e. nothing. Whereas the call DelDirFile[w, y] with the 2nd optional argument y – an arbitrary expression – removes from file system of the computer a file or a directory w, irrespectively from existence of attribute Read–only for it. The DelDirFile1 procedure is a rather useful extension of the DelDirFile procedure [2] on a case of open files in addition to the Read–only attribute of both the separate files, and the files being in the deleted directory. The procedure call DelDirFile1[x] is equivalent to the call DelDirFile[w, y], providing removal of a file or directory x irrespective of openness of a separate w file and the Read–only attribute ascribed to it, or existence of similar files in w directory. The fragment represents source code of the DelDirFile1 procedure along with typical examples of its use.

In[2242]:= DelDirFile1[x_ /; StringQ[x] && FileExistsQ[x] ||

DirQ[x] && If[StringLength[x] == 3 && StringTake[x, {2, 2}] == ":", False, True]] := Module[{a = {}, b = "", c = Stilized[x], d, f = "#$#", k = 1},

If[DirQ[x], Run["Dir " <> c <> " /A/B/OG/S > " <> f]; Attribs[c, 7]; For[k, k < Infinity, k++, b = Read[f, String]; If[SameQ[b, EndOfFile], DeleteFile[Close[f]]; Break[], Attribs[b, 7]; Close2[b]]]; DeleteDirectory[x, DeleteContents –> True], Close2[x]; Attribs[x, 7]; DeleteFile[x]]]

In[2243]:= Attribs["c:\\temp\\paper_201120.docx"]

Out[2243]= {"A", "S", "H", "R"}

In[2244]:= DelDirFile1["c:\\temp\\paper_201120.docx"]

In[2245]:= FileExistsQ["c:\\temp\\paper_201120.docx"]

Out[2245]= False

In[2246]:= DirectoryQ["c:\\temp\\Rans_IAN"]

Out[2246]= True

In[2247]:= Attribs["c:\\temp\\Rans_IAN"]

Out[2247]= {"A", "S", "H", "R"}

In[2248]:= DelDirFile1["c:\\temp\\Rans_IAN"]

In[2249]:= DirectoryQ["c:\\temp\\Rans_IAN"]

Out[2249]= False

324

Mathematica: Functional and procedural programming

Meanwhile, before representation of the following means it is expedient to determine one a rather useful procedure whose essence is as follows. As noted above, the file qualifier depends both on register of symbols, and the used dividers of directories. So, the same file with different qualifiers "c:\\Tmp\\cinem.txt" and "c:/tmp/cinem.txt" opens in 2 various streams. Therefore its closing by means of the built-in Close function doesn't close the "cinem.txt" file, demanding closing of all streams on which it was earlier open. For solution of this problem the Close1 and Close2 procedures have been programmed.

In[3]:= Read["C:/Temp\\paper_201120.docx"]; Read["C:/Temp/paper_201120.docx"]; Read["C:/Temp\\Paper_201120.docx"]; Read["c:/temp/paper_201120.Docx"]; StreamsU[]

Out[3]= {InputStream["C:/Temp\\paper_201120.docx", 3], InputStream["C:/Temp/paper_201120.docx", 4], InputStream["C:/Temp\\Paper_201120.docx", 5], InputStream["c:/temp/paper_201120.Docx", 6]}

In[4]:= Close["C:\\Temp\\paper_201120.docx"]

…General: C:\Temp\paper_201120.docx is not open. Out[4]= Close["C:\\Temp\\paper_201120.docx"]

In[5]:= StreamsU[]

Out[5]= {InputStream["C:/Temp\\paper_201120.docx", 3], InputStream["C:/Temp/paper_201120.docx", 4], InputStream["C:/Temp\\Paper_201120.docx", 5], InputStream["c:/temp/paper_201120.Docx", 6]}

In[5]:= Close1[x___String] := Module[{a = Streams[][[3 ;; –1]],

b = {x}, c = {}, k = 1, j}, If[a == {} || b == {}, {}, b = Select[{x}, FileExistsQ[#] &];

While[k <= Length[a], j = 1; While[j <= Length[b], If[Stilized[a[[k]][[1]]] == Stilized[b[[j]]], AppendTo[c, a[[k]]]]; j++]; k++]; Map[Close, c]; If[Length[b] == 1, b[[1]], b]]]

In[7]:= Close1["C:\\Temp\paper_201120.docx"]

Out[7]= "C:\\Temp\\paper_201120.docx"

In[13]:= StreamsU[]

Out[13]= {}

325

V.Z. Aladjev, M.L. Shishakov, V.A. Vaganov

In[21]:= Close2[x___String] := Module[{a = Streams[][[3 ;; –1]], b = {}, c, d = Select[{x}, StringQ[#] &]},

If[d == {}, {}, c[y_] := Stilized[y];

Map[AppendTo[b, Part[#, 1]] &, a]; d = DeleteDuplicates[Map[c[#] &, d]]; Map[Close, Select[b, MemberQ[d, c[#]] &]]]]

In[22]:= Close["C:\\Temp\\paper_201120.docx"]

…General: C:\Temp\paper_201120.docx is not open. Out[22]= Close["C:\\Temp\\paper_201120.docx"] In[23]:= Close2["C:\\Temp\\paper_201120.docx"]

Out[23]= {"C:/Temp\\paper_201120.docx", "C:/Temp/paper_201120.docx", "C:/Temp\\Paper_201120.docx", "c:/temp/paper_201120.Docx"}

In[24]:= StreamsU[]

Out[24]= {}

The call Close1[x, y, z, …] closes all off really–existing files in a {x, y, z, …} list irrespective of quantity of streams on which they have been opened by means of various files qualifiers with returning their list. In other cases the call on admissible factual arguments returns the empty list, while on inadmissible factual arguments a call is returned unevaluated. The procedure Close2 is a functional analogue of the above procedure Close1. The call Close2[x, y, z,…] closes all off really–existing files in a {x, y, z,…} list irrespective of quantity of streams on which they have been opened by various files qualifiers with returning their list. The call on any admissible factual arguments returns the empty list, whereas on inadmissible actual arguments the call is returned unevaluated. The previous fragment represents source codes of both procedures along with examples of their use. In a number of appendices Close1 and Close2 are quite useful means.

The tools representing a quite certain interest at operating with file system of the computer as independently and as a part of tools of files processing and directories complete the section. They are used and by a number of means of our MathToolBox package [16]. In particular, at operating with files the OpenFiles

326

Mathematica: Functional and procedural programming

procedure can be rather useful, whose call OpenFiles[] returns the two–element nested list, whose the first sub-list with the 1st "read" element contains full paths to the files opened on reading whereas the 2nd sub-list with the first "write" element contains full paths to files opened on writing in the current session. In a case of absence of such files the call returns the empty list, i.e. {}. Whereas the call OpenFiles[x] with one factual x argument – a file classifier – returns the result of the above format relative to an open x file irrespective of a format of coding of its qualifier. If x defines a closed or a nonexistent file then the procedure call returns the empty list, i.e. {}. The following fragment represents source code of the procedure with a typical example of its use.

In[333]:= OpenFiles[x___String] := Module[{a = StreamsU[],

b, c, d, h1 = {"read"}, h2 = {"write"}}, If[a == {}, {}, d = Map[{Part[#, 0], Part[#, 1]} &, a]; b = Select[d, #[[1]] == InputStream &]; c = Select[d, #[[1]] == OutputStream &]; b = Map[DeleteDuplicates,

Map[Flatten, Gather[Join[b, c], #1[[1]] == #2[[1]] &]]]; b = Map[Flatten, Map[If[SameQ[#[[1]], InputStream], AppendTo[h1, #[[2 ;; –1]]], AppendTo[h2, #[[2 ;; –1]]]] &, b]]; If[{x} == {}, b, If[SameQ[FileExistsQ[x], True], c = Map[Flatten, Map[{#[[1]], Select[#, Stilized[#] === Stilized[x] &]} &, b]]; If[c == {{"read"}, {"write"}}, {}, c = Select[c, Length[#] > 1 &]; If[Length[c] > 1, c, c[[1]]], {}]]]]]

In[334]:= Write["c:/temp\\paper_201120.docx", 211120]; Read["C:/Temp/paper_201120.docx"];

In[335]:= OpenFiles["C:\\temp\\paper_201120.docx"]

Out[335]= {{"read", "C:/Temp/paper_201120.docx"}, {"write", "c:/temp\\paper_201120.docx"}}

As a procedure similar to the OpenFiles, the procedure can be used, whose call StreamFiles[] returns the nested list from 2 sub-lists, the first sub-list with the first "in" element contains full paths/names of the files opened on the reading whereas the 2nd sublist with the first "out" element contains full paths/names of the files opened on the recording. Whereas in the absence of the open files the call StreamFiles[] returns "AllFilesClosed".

327

V.Z. Aladjev, M.L. Shishakov, V.A. Vaganov

In[2336]:= StreamFiles[]

Out[2336]= {{"in", "C:/Temp/paper_201120.docx"}, {"out", "c:/temp\\paper_201120.docx"}}

In[2337]:= CloseAll[]; StreamFiles[]

Out[2337]= "AllFilesClosed"

The following procedure is represented as a rather useful tool at operating with file system of the computer, whose call DirEmptyQ[w] returns True if w directory is empty, otherwise False is returned. At that, the procedure call DirEmptyQ[w] is returned unevaluated, if w isn't a real directory. At the same time, the call DirEmptyQ[w, y] with optional argument y – an indefinite variable – through y returns the contents of w directory in format of Dir command of MS DOS. The following fragment presents source code of the DirEmptyQ procedure with typical enough examples of its application.

In[3128]:= DirEmptyQ[d_ /; DirQ[d], y___] :=

Module[{a, b = {"$$1", "$$2"}, c, p = Stilized[d], t = 1},

Map[Run["Dir " <> p <> If[SuffPref[p, "\\", 2], "", "\\"] <> # <> " > " <> b[[t++]]] &, {" /S/B ", " /S "}]; c = If[ReadString[b[[1]]] === EndOfFile, True, False]; If[{y} != {} && SymbolQ[y],

y = StringReplace[ReadString[b[[2]]], "\n" –> ""], 7]; DeleteFile[b]; c]

In[3129]:= DirEmptyQ["c:\\Galina47"]

Out[3129]= DirEmptyQ["c:\\Galina47"]

In[3130]:= DirEmptyQ["c:\\Galina", gs]

Out[3130]= False

In[3131]:= gs

Out[3131]= "Volume in drive C is OS

Volume Serial Number is E22E-D2C5

Directory of c:\\galina\\Victor

328

Mathematica: Functional and procedural programming

In addition to the previous DirEmptyQ procedure the call DirFD[j] returns the 2-element nested list whose the 1st element determines the list of subdirectories of the first nesting level of a j directory whereas the second element – the list of files of a j directory; if the j directory is empty, the procedure call returns the empty list, i.e. {}. The fragment below presents source code of the DirFD procedure with an example of its application.

In[320]:= DirFD[d_ /; DirQ[d]] := Module[{a = "$#$", b = {{}, {}}, c, h, t, p = StandPath[StringReplace[d, "/" –> "\\"]]}, If[DirEmptyQ[p], Return[{}], Null]; c = Run["Dir " <> p <> " /B " <> If[SuffPref[p, "\\", 2], "", "\\"]

<> "*.* > " <> a]; t = Map[ToString, ReadList[a, String]]; DeleteFile[a]; Map[{h = d <> "\\" <> #; If[DirectoryQ[h], AppendTo[b[[1]], #], If[FileExistsQ[h], AppendTo[b[[2]], #], Null]]} &, t]; b]

In[321]:= DirFD["C:\\Program Files\\Wolfram Research\\

Mathematica\\12.1\\Documentation\\English\\Packages"]

Out[321]= {{"ANOVA", "Audio", "AuthorTools", …, {}}} In[322]:= Length[%[[1]]]

Out[322]= 48

In particular, in the previous example the list of directories with records on the packages delivered with the Mathematica 12.1 is returned. So, with Mathematica 48 packages of different purpose that is simply seen from the name of the subdirectories containing them are being delivered.

In addition to the DirFD procedure, the DirFull procedure presents a certain interest whose call DirFull[j] returns list of all full paths to subdirectories and files contained in a j directory and its subdirectories; the 1st element of the list is the j directory. Whereas on an empty j directory the call returns the empty list.

329

V.Z. Aladjev, M.L. Shishakov, V.A. Vaganov

At last, the procedure call TypeFilesD[d] returns the sorted list of types of files located in a d directory with returning word "undefined" on files without of name extension. In addition, the files located in the d directory and in all its subdirectories of an arbitrary nesting level are considered. Moreover, on the empty d directory the call TypeFilesD[d] returns the empty list, i.e. {}.

The FindFile1 procedure serves as a useful extension of the standard FindFile function, providing search of a file within file system of the computer. The call FindFile1[x] returns a full path to the found file x, or the list of full paths (if the x file is located in different directories of file system of the computer), otherwise the call returns the empty list. Whereas the call FindFile1[x, y] with the 2nd optional y argument – full path to directory – returns full path to the found x file, or list of full paths located in the y directory and its subdirectories. At the same time, the FindFile2 function serves as other useful extension of standard FindFile function, providing search of a y file within a x directory. The function call FindFile2[w, y] returns the list of full paths to the found y file, otherwise the call returns the empty list. Search is done in the w directory and all its subdirectories. The fragment below presents source codes of the FindFile1 procedure and FindFile2 function with some typical examples of their application.

In[7]:= FindFile1[x_ /; StringQ[x], y___] := Module[{c, d={}, k= 1, a = If[{y} != {} && PathToFileQ[y], {y}, Map[# <> ":\\" &, Adrive[]]], b = "\\" <> ToLowerCase[x]},

For[k, k <= Length[a], k++, c = Map[ToLowerCase, Quiet[FileNames["*", a[[k]], Infinity]]]; d = Join[d, Select[c, SuffPref[#, b, 2] && FileExistsQ[#] &]]]; If[Length[d] == 1, d[[1]], d]]

In[8]:= FindFile1["Book_2020.doc"]

Out[8]= {"c:\\ma\\book_2020.doc", "e:\\ma\\book_2020.doc"}

In[9]:= FindFile2[x_ /; DirectoryQ[x], y_ /; StringQ[y]] :=

Select[FileNames["*.*", x, Infinity], Stilized[FileNameSplit[#][[–1]]] == Stilized[y] &]

In[10]:= FindFile2["e:\\", "book_2020.doc"]

Out[10]= {"e:\\Mathematica\\Book_2020.doc"}

330