WOLFRAM

Wolfram Language & System Documentation Center

WXF (.wxf)

Background & Context

    • Wolfram exchange format.
    • Binary format.
    • Represents arbitrary Wolfram Language expressions in a serialized, platform-independent form.
    • Versioned format.
    • Developed in 2017 by Wolfram Research.

Import & Export

Import Elements

  • General Import elements:
  • "Elements" list of elements and options available in this file
    "Summary"summary of the file
    "Rules"list of rules for all available elements
  • Import elements:
  • "Expression"returns the serialized expression
    "HeldExpression"returns the expression wrapped in HoldComplete
    "ExprStruct"returns the expression as an "ExprStruct" data structure
  • Import by default uses the "Expression" element for Wolfram Language WXF files.

Options

Examples

open all close all

Basic Examples  (4)

Export an expression to WXF:

Wolfram Language code: ExportByteArray[{1, 2, 3}, "WXF"]

Export a string to WXF:

Wolfram Language code: ExportByteArray["hello!", "WXF"]

Export a symbolic expression to WXF:

Wolfram Language code: ExportByteArray[f[Cos[2Pi α]], "WXF"]

Import as an expression:

Wolfram Language code: ImportByteArray[%, "WXF"]

Export an arbitrary Wolfram Language expression to the WXF format:

Wolfram Language code: bytes = ExportString[Plot3D[Sin[x] Cos[2 y], {x, -2, 2}, {y, -3, 3}], "WXF"];

Import as an expression:

Wolfram Language code: ImportString[bytes, "WXF"]

Scope  (2)

Serialize an expression to a WXF byte array:

Wolfram Language code: bytes = ExportByteArray[GeoGraphics[GeoCircle[Here, Quantity[3, "Kilometers"]]], "WXF"]

Deserialize the output using BinaryDeserialize:

Wolfram Language code: BinaryDeserialize[bytes]

Serialize an expression to a WXF byte array:

Wolfram Language code: bytes = BinarySerialize[RandomImage[1, {2, 2}, ColorSpace -> "RGB"]]

Import it using automatic format detection:

Wolfram Language code: ImportByteArray[bytes]

Import Elements  (4)

List available elements:

Wolfram Language code: Import["ExampleData/atoms.wxf", "Elements"]

Serialize an unevaluated expression:

Wolfram Language code: bytes = BinarySerialize[Unevaluated[1 + 1]]

Import it using the default element "Expression":

Wolfram Language code: ImportByteArray[bytes]

Import it in a held form using the element "HeldExpression":

Wolfram Language code: ImportByteArray[bytes, {"WXF", "HeldExpression"}]

Get WXF data from an untrusted source:

Wolfram Language code: wxf = ByteArray["ODpmAHMKQ2xvY2tHYXVnZQ=="];

Inspect the element "HeldExpression":

Wolfram Language code: ImportByteArray[wxf, {"WXF", "HeldExpression"}]

The code is safe; evaluate it:

Wolfram Language code: ImportByteArray[wxf, {"WXF", "Expression"}]

Import bytes with the element "ExprStruct":

Wolfram Language code: bytes = BinarySerialize[Unevaluated[Print[1 + 1]]]; ImportByteArray[bytes, {"WXF", "ExprStruct"}]

The expression is held in an unevaluated state:

Wolfram Language code: %["ConstructWith", Hold]["Get"]

Export Options  (5)

PerformanceGoal  (2)

Serialize an expression using BinarySerialize to produce a compressed output:

Wolfram Language code: bytes = BinarySerialize[Range[5], PerformanceGoal -> "Size"]

Import the resulting byte array:

Wolfram Language code: ImportByteArray[bytes, "WXF"]

Serialize a dataset:

Wolfram Language code: bytes = ExportString[ExampleData[{"Statistics", "USCityTemperature"} ], "WXF"];

Serialize the same dataset with PerformanceGoal set to "Size":

Wolfram Language code: compressed = ExportString[ExampleData[{"Statistics", "USCityTemperature"} ], "WXF", PerformanceGoal -> "Size"];

Compute the size of the outputs:

Wolfram Language code: Column[{Quantity[ByteCount[bytes], "Bytes"], Quantity[ByteCount[compressed], "Bytes"]}]

Both represent the same expression:

Wolfram Language code: ImportString[bytes, "WXF"] === ImportString[compressed, "WXF"]

Method  (3)

By default, the WXF serialization of packed arrays of integers uses the smallest integer type that fits the data:

Wolfram Language code: ExportByteArray[Range[3], "WXF"]

Export a packed array using a bigger integer type:

Wolfram Language code: ExportByteArray[Range[3], "WXF", Method -> "PackedArrayIntegerType" -> "Integer32"]

Create a packed array of real values:

Wolfram Language code: reals = RandomReal[10, 4]

By default, the WXF serialization of a packed array of real values uses machine doubles:

Wolfram Language code: ExportByteArray[reals, "WXF"]

Export the array using machine floats:

Wolfram Language code: ExportByteArray[reals, "WXF", Method -> {"PackedArrayRealType" -> "Real32"}]

Create a packed array of complex values:

Wolfram Language code: complexes = RandomComplex[1 - I, 2]

By default, the WXF serialization of packed array of complex values uses two machine doubles to represent one complex value:

Wolfram Language code: ExportByteArray[complexes, "WXF"]

Export the array using lower precision:

Wolfram Language code: ExportByteArray[complexes, "WXF", Method -> {"PackedArrayComplexType" -> "Complex64"}]

Properties & Relations  (2)

ExportByteArray[expr,"WXF"] is effectively equivalent to BinarySerialize[expr]:

Wolfram Language code: ExportByteArray[{1, 2, 3}, "WXF"] === BinarySerialize[{1, 2, 3}]

ImportByteArray[ba,"WXF"] is effectively equivalent to BinaryDeserialize[ba]:

Wolfram Language code: ba = ByteArray[{56, 58, 102, 3, 115, 4, 76, 105, 115, 116, 67, 1, 67, 2, 67, 3}];
Wolfram Language code: ImportByteArray[ba, "WXF"] === BinaryDeserialize[ba]