Storing data in the Notebook in readable form

Question

The common problem in my work is a need to import some experimental data to work with. This means that my notebook depends on some external files which makes it difficult to share it with others and inconvenient when I return to it after time.

What I wish is to have a way to store the data inside the Notebook in collapsible CellGroups in order to have an ability to view the data in human-readable tabular form and to re-import the data file manually if I change it.

Generally, the data inside of the notebook should look as on the screenshot:

The output Сells are regenerated by pressing Shift + Enter when the data files change. What I need is a way to retrieve the data sets from the output cells in the section "The data cells". Something like this:

dataSet1 = getData["Data set 1"];
dataSet2 = getData["Data set 2"];

where "Data set 1" and "Data set 2" are the text strings in the Subsubsection cells from the section "The data cells".

How to achieve this?

Answer 1

I use buttons for this purpose. Imagine that your data is stored in a variable called data. Then you can do the following:

With[{i = Compress[data]}, 
  Button["Retrieve Data", data = Uncompress[i]; 
  Print[Style["Data has successfully been loaded into variable \"data\"",Blue,Italic,14]]]
]

This creates a button. When pressed, data is populated with your original data.

A warning: If you have a separate variable data already as part of your notebook, it will be overwritten.

An alternative:

Create initiialization cells somewhere in your notebook containing

data1 = <your data 1>;
data2 = <your data 2>;

To save space you can also do

data1 = Uncompress[Compress[<your data 1>]];

Then, highlight Compress[<your data 1>] and evaluate it in place (Ctrl-Shift-Enter)

Answer 2

I put in a defer because of your question here. Maybe you have symbols in your data and this will be useful, who knows. getData succesfully gets the data from the generated cell.

int = 1;
With[
  {string = "@#$kill me" <> ToString[int]}
  ,
  NotebookDelete[Cells[CellTags -> string]]; 
  CellPrint[
   ExpressionCell[
    Defer[{{1 + 1, 2}, {1 + 1, 2}, {1 + 1, 2}} // TableForm], 
    "Output", GeneratedCell -> True, Evaluatable -> True, 
    CellTags -> string]]
  ];

getDataHeldComplete[int_] := 
 With[
  {string = "@#$kill me" <> ToString[int]}
  ,
  MakeExpression @@ {NotebookRead[Cells[CellTags -> string][[1]]][[
     1]], StandardForm}
  ]

getData[int_] := getDataHeldComplete[1][[1]];

Then evaluate evaluate in a new cell

getDataHeldComplete[1]
data=getData[1]

Answer 3

You may use TableForm (you're already using this), CellTags, NotebookLocate, and NotebookRead to do this.

For your Import "Output" cell add a CellTag that will be your reference.

CellPrint[ExpressionCell[
  ImportString["1,2,3,4,5,6,7,8,9", "CSV"] // TableForm,
  "Output",
  CellTags -> "Data1"]]

This can be re-executed at any time going forward without having to manually adjust. Of course you will use Import and not ImportString.

The cell can be located in the notebook with NotebookLocate and its contents read with NotebookRead. When this is done you will see that the data is in a GridBox command. getCellTableFormData finds the first occurrence of this and returns the first argument; which is the data array.

getCellTableFormData[tag_String] :=
 Module[{},
  NotebookLocate[tag];
  With[{cell = NotebookRead[EvaluationNotebook[]]},
   ToExpression@First@Extract[cell, FirstPosition[cell, GridBox[__]]]
   ]
  ]

Now getCellTableFormData can be used to assign a variable to the data collected from the tagged cell of TableForm output.

dat = getCellTableFormData["Data1"]
(* {{"1", "2", "3", "4", "5", "6", "7", "8", "9"}} *)

Even after you close and reopen the notebook the tagged cell is still there. So all that is need is to run the getCellTtableFormData definition (initialisation cell or a package) so that the variables can be set from the tagged cell data.

Hope this helps.

---

Update

Here is a version that does not change the selected cell to the tagged cell when the data is assigned to the variable. It is also a more concise.

getCellTableFormData2[tag_String] :=
 With[{cell = NotebookRead@First@Cells[CellTags -> tag]},
  ToExpression@First@Extract[cell, FirstPosition[cell, GridBox[__]]]
  ]

It does not use NotebookLocate which sets the selected cell to the tagged cell.

Answer 4

Are you aware that you can write data= before your table and evaluate ? :

Answer 5

Here is the solution which I currently use. It isn't perfect but serves quite well for my purposes.

In the Notebook I define an auxiliary function which takes a variable where a data array is stored and prints an initialization Cell with two-dimensional human-readable representation of that array which will be assigned to the input variable on initialization:

ClearAll[printInitCell];
SetAttributes[printInitCell, HoldAll];
printInitCell[array_] := 
  CellPrint@Cell[
    BoxData[RowBox[{ToString[Unevaluated[array]], "=", 
       GridBox[Map[ToBoxes, array, {-1}], 
        GridBoxFrame -> {"Columns" -> {{True}}, "Rows" -> {{True}}}], ";"}]], "Output", 
    InitializationCell -> True, Evaluatable -> True];

Here is an example of use:

dataset1 = Prepend[RandomReal[1, {5, 3}], {"Head1", "Head2", "Head3"}];
printInitCell[dataset1]

It is important that after initialization the variable dataset1 contains two-dimensional array which is not wrapped by Grid:

The only drawback of this approach is that when I need to re-generate the initialization Cell, I have to remove the previous Cell manually.

---

UPDATE

With AutoIndent -> False and the variable placed above the data table the data Cells are more readable:

ClearAll[printInitCell];
SetAttributes[printInitCell, HoldAll];
printInitCell[array_] := 
  CellPrint@Cell[
    BoxData[RowBox[{ToString[Unevaluated[array]], " ", "=", " ", "\n", 
       GridBox[Map[ToBoxes, array, {-1}], 
        GridBoxFrame -> {"Columns" -> {{True}}, "Rows" -> {{True}}}, 
        BaseStyle -> (FontWeight -> Plain)], ";"}]], "Output", InitializationCell -> True,
     Evaluatable -> True, AutoIndent -> False, Background -> GrayLevel[0.95], 
    FontWeight -> Bold];

Now

---

UPDATE 2

Here is Mathematica 8 - compatible solution which auto-overwrites previous version of the data Cell (if present) before printing of the new version.

At first, it checks whether the next Cell is a previous version by comparing the CellTags. If the latter is true it sets the Evaluatable -> False option what turns on automatic overwriting. Then it prints the new version and collapses the CellGroup hiding everything except to the newly printed initialization cell.

ClearAll[printInitCell];
SetAttributes[printInitCell, HoldAll];
printInitCell[var_] := With[{tag = ToString[Unevaluated[var]], nb = EvaluationNotebook[]},
   SelectionMove[nb, After, EvaluationCell, AutoScroll -> False];
   SelectionMove[nb, Next, Cell, AutoScroll -> False];
   If[CurrentValue[NotebookSelection[], CellTags] === {tag, "CellType=DataCell"}, 
    SetOptions[NotebookSelection[], Evaluatable -> False]];
   CellPrint@
    Cell[BoxData[
      RowBox[{ToString[Unevaluated[var]], " ", "=", " ", "\n", 
        GridBox[Map[ToBoxes, var, {-1}], 
         GridBoxFrame -> {"Columns" -> {{True}}, "Rows" -> {{True}}}, 
         BaseStyle -> (FontWeight -> Plain)], ";"}]], "Output", 
     InitializationCell -> True, Evaluatable -> True, AutoIndent -> False, 
     Background -> GrayLevel[0.95], FontWeight -> Bold, 
     CellTags -> {tag, "CellType=DataCell"}];
   SelectionMove[nb, Previous, Cell];
   FrontEndTokenExecute["OpenCloseGroup"]];