New answers tagged import
3
Using BlockStream from this answer and the techniques from this answer, this is how I would load an LTSpice using the sample as a template:
ClearAll[toRule, skip];
Options[toRule] = {Trim -> True};
toRule[s_String, opts : OptionsPattern[]] := toRule[s, ":", opts]
toRule[s_String, del_, opts : OptionsPattern[]] :=
Rule @@ If[OptionValue[Trim], ...
3
The following works :
fileFullName = (*to be defined by you*)
page = 1;
ti00 = Import[fileFullName, "Text"] //
StringReplace[#, {Except[StartOfString] ~~ "Title" ->
"TitleTitle"}] & //
StringSplit[#,
Shortest["Title: " ~~ x : ___ ~~ "Title"] :>
"Title: " <> x] & //
(#[[page]] &) //
...
3
Lets do an exercise importing and exporting JPEG data. First let's create a tiny single pixel JPEG file:
In[1]:= Export["~/Desktop/minitest.jpg", Image[{{0}}]]
Now lets import the binary data that we have just created:
In[2]:= Import["/Users/gdelfino/Desktop/minitest.jpg", "Binary"]
Out[2]:= {255, 216, 255, 224, 0, 16, 74, 70, 73, 70, 0, 1, 1, 1, 0, 72, ...
3
Your binarydata seems to be a string with hexadecimal digits. Converting this using FromCharacterCode yields nonsense, of course.
It can be solved in a few steps:
0) The string:
imageString =
"FFD8FFE000104A46494600010201006000600000FFEE000E41646F6265006400000\
00001FFE1135D4578696600004D4D002A0000000800070132000200000014000000620\
...
1
If the file is very large and importing it takes too much memory, you can use external tools to cut the columns you are interested in. You can often call these tools directly from Mathematica, for example
ReadList["!awk '{print $1, $4}' file.txt", {Number, Number}]
This will use awk to cut columns 1 and 4. ReadList, with an explicit specification of the ...
6
What about this:
Import["ExampleData/wrench.obj.gz", "PolygonObjects"] // Graphics3D
You can use the FaceForm[None] trick as shown by @J.M. here just as well if you only want the wireframe looks.
7
At OP's behest:
The easiest approach to see the mesh lines is to remove the EdgeForm[] instruction that causes them not to appear. For instance,
DeleteCases[Import["ExampleData/wrench.obj.gz"], _EdgeForm, ∞]
As SEngstrom suggests, you can also use a replacement rule. If, for instance, you want a thick gray mesh, here's what you can do:
...
6
This is a bug due to the fact that URLFetch is dealing incorrectly with line breaks. Here's a workaround:
in1 = URLFetch[
"http://blog.wolfram.com/wp-content/uploads/2008/06/se-30.jpg",
"ContentData"
];
ImportString[FromCharacterCode[in1]]
You can compare this technique to the other as follows:
in2 = ToCharacterCode[URLFetch[
...
5
I recently had a similar task decoding 12-bit binary 24-channel electroencephalogram data files and found that bit shifting and masking with BitAnd are the way to go. The specific approach depends on file structure, endianness and channel number. In the case of this 'format 212' binary data file containing two interlaced signals, the following procedure ...
5
If I am not mistaken the 212 format is storing two signals and each 3-byte group provides a 12-bit reading of that pair. Importing with Byte isn't too bad for this set:
data = Import["http://physionet.org/physiobank/database/mitdb/100.dat", "Byte"] ~ Partition ~ 3
Then two helpers to parse it:
twosComplement[a_, n_] := If[a < 2^(n - 1), a, a - 2^n]
...
1
Another variant..
twoscomplement[bin_] := If[First@bin != 1,
FromDigits[bin, 2], BitOr[FromDigits[bin, 2], -2^12]]
or to be safe..
twoscomplement[bin_List /; Length[bin] == 12] := If[First@bin != 1,
FromDigits[bin, 2], BitOr[FromDigits[bin, 2], -2^12]]
3
This might work... however, it is very inefficient.
Slightly faster using Import instead of BinaryReadList:
binary= Partition[Import["http://physionet.org/physiobank/database/mitdb/100.dat", "Bit"], 12];
twoscomplement[bin_] :=
If[First@bin != 1,
FromDigits[Rest@bin, 2],
-FromDigits[Rest@bin /. {1 -> 0, 0 -> 1}, 2] - 1
]
output = ...
0
There are of course many possibilities to achieve what you want. Here is one which imports and then rearranges, of course that will only work if you know how many columns per matrix there are:
data = Insert[#, "|", 8] & /@
Import[ToFileName[{$HomeDirectory}, "R1"], "Table",
"FieldSeparators" -> {" ", ",", "\t"}]
Here is another method which ...
1
A way to do this is to use rules. You have four things that can happen, so you can write four rules to substitute.
data//. {"0\t0" -> {0, 0}, "1\t0" -> {1, 0}, "0\t1" -> {0, 1}, "1\t1" -> {1, 1}}
Then you need to reshape the data. Flatten the output of the above and then partition it into the matrices of the correct size:
data2 = ...
1
ReadList thinks your file has lists of 4, not 5, elements; it views the minutes and the "m" as a single element. The following will import the lists.
dd = ReadList["/tmp/data8.txt", {Word, Word, Number, Character}]
{{"Apr-09", "-1m", 47, "s"}, {"Apr-11", "-1m", 15, "s"}, {"Apr-12",
"-0m", 59, "s"}, {"Apr-13", "-0m", 44, "s"}, {"Apr-14", "-0m", ...
1
You'll want to use Algorithm R for reservoir sampling to get a truly random sample (as opposed to periodic) with only one scan of the input and no need to know the length of the input in advance. Basically, you take the first items and then randomly replace them with decreasing frequency as you complete the scan.
sampleSize = 100;
stream = ...
4
Since you requested performance I would avoid Import and DateList and use ReadList and AbsoluteTime.
format = {Number, Character, Number, Character, Number, Number,
Character, Number, Character, Number, Number, Word};
data = {AbsoluteTime[{#5, #3, #1, #6, #8, #10}], ##11} & @@@ ReadList["data.txt", format];
"data.txt" is of course your data ...
6
Import is very well able to handle this format. As a demonstration I use its nephew ImportString to deal with the few lines from your example:
data =
ImportString[
"28/04/2013 20:01:36.18 2.5013E-2 W
28/04/2013 20:01:36.26 2.5013E-2 W
28/04/2013 20:01:36.32 2.5013E-2 W
28/04/2013 20:01:36.35 2.5011E-2 W
28/04/2013 20:01:36.48 ...
2
A simplistic,if slightly inefficient, solution might be:
data = Import[#,"Table"][[39;;-3]]&/@Filenames[];
Other options might involve, 'Cases', 'Choices', Drop, Take.
For example:
data = Drop[Drop[Import[#,"Table"],38],-2]&/@Filenames[];
If you are using a Linux derivative or something like cygwin on Windows, then this is an efficient ...
3
You can wrap your Skip and Readlist in a Module and make it a function:
importfile[name_] := Module[{strm, mydata},
strm = OpenRead[name];
Skip[strm, Record, 38, NullRecords -> True];
mydata = ReadList[strm, Number, 7500*3, RecordLists -> True];
Close[strm];
mydata
]
importfile@"f1-Oxs_TimeDriver-Magnetization-000000-0000028.omf"
This ...
3
Via @chuy and @rcollyer with sequential skipping and reading of records, and without backtracking.
(
If[# != 1, Skip[s, Record, # - 1], Null];
ReadList[s, Number, 2]) & /@ Differences[p~Prepend~0]
List p of lines you want to read, sorted; eg. some random ten from a hundred:
p = Sort[RandomSample[Range[100], 10]];
Your file opened as a stream, ...
1
By importing that URL you are asking Mathematica to do something overly complex, since you are asking it to parse the page source code for the Google Docs interface. Even if Mathematica could process it, all you would have would be symbolic XML representing that HTML code, not the values that you want.
It should however work to import the data if you export ...
4
Surely not the fastest or ideal solution, but this should work (it assumes that you have two numbers in each row):
randomline[str_InputStream, num_] := (
SetStreamPosition[ str, 0];
Skip[str, Record, num-1];
Read[str, {Number, Number}])
str = OpenRead["data.txt"];
Now, if you have 2000 lines and want 100 random samples:
Map[randomline[str, #] ...
0
This can be done. Your description looks as if the file you get from C is a dat file. Let us assume it is called data.dat. One way to easily import it is to first save your notebook into the directory, where you have the file in question, and then import the data.dat file into this notebook as follows:
dataList = Import[NotebookDirectory[] <> ...
1
First Import the file. Depending on the structure of your .txt file you can use the second argument ("Data" and "List" are useful choices). Remove the parts you don't need (in this case the ------) and split the resulting strings. An empty list shows up from all the dashed, you can simply remove this using /. {} -> Sequence[].
foo = (StringSplit /@ ...
1
First, import it:
q = Import["yourPath/example.txt"]
Then you can look to see what it consists of using
FullForm[q]
where you see it is a big string. So break it apart:
StringSplit[q]
and you get roughly the desired form.
Top 50 recent answers are included
