GAUSS packages provide access to powerful tools for performing data analysis. Learn how to install the GAUSS Package Manager, and get the quickest access to the full suite of GAUSS packages, in this short video.

Additional Resources

• GAUSS Package Manager
• Using GAUSS Packages a Complete Guide

There is no getting around the fact that data wrangling, cleaning, and exploring plays an important role in any empirical research. Data management can be time-consuming, error-prone, and can make or break results.

GAUSS 22 is built to take the pain out of dealing with your data and to let you move seamlessly towards tackling your important research questions.

In today’s blog, we walk through how to efficiently prepare and explore real-world data before modeling or estimation. We'll look at:

• Loading data.
• Cleaning data to eliminate misentries, missing values, and more.
• Exploring data.

Throughout the blog, we will use Kick Starter 2018 data available on Kaggle.

Loading Data

Let's get started by opening up our data in the Data Import window. This can be done two ways:

• Selecting File > Import Data from the main GAUSS menu.
• Double-clicking the filename in the Project Folders window.

The data preview shows us exactly how our data will be loaded and is useful for identifying data issues before we even load our data.

We can tell from the data preview if:

• Our data has any additional headers that shouldn't be loaded.
• There are unintended symbols or unacceptable characters.
• Observations are missing.
• Data is loading as the type we intend.

For example, in the data preview of our Kickstarter data, we can see that GAUSS is detecting that the variable Category is a string. In the next section, we'll look at how to change this to a categorical variable.

Managing Data in the Data Import Window

Let's look at how to complete preliminary data cleaning using the Import Window. Specifically, we will:

1. Change the dataframe name for more convenient referencing.
   • For the Kickstarter data, the default symbol name is ks_projects_201801.
   • Let's change this to a simpler name, ks_projects, using the Symbol Name textbox.
     When importing data with the Data Import tool, GAUSS uses the filename, minus the extension, as the default symbol name.
2. Change the Category variable type from String to Category.
   • Variable types are changed using the Type drop-down menu in the Variables list.
   • If necessary, we can change the categorical mappings using the Modify Column Mapping dialog.
3. Remove unneeded variables from the import list to avoid workspace clutter.
   • Raw datasets often contain excess variables that we don't need.
   • Our Kickstarter data contains the fundraising pledges in local currency and in real USD.
   • We can deselect the variable pledged, along with currency from Variables.
4. Filter the data to build the appropriate model.
   • Datasets often also contain excess observations that we don't want to include in our model.
   • The Filter tab is a quick and easy way to remove observations.
   • Let's filter our data to remove all observations with launch dates earlier than "2015".

After performing our preliminary data cleaning steps, we click Import to load our data.

Reusable Auto-generated Code

One of the most powerful features of the Data Import tool is that it auto-generates the code for all of our steps performed using the Data Import tool.

/*
** Perform import
*/
ks_projects = loadd("C:/research/data/ks-projects-201801.csv", "ID + str(name) + cat(category) + cat(main_category) + date($deadline) + date($launched) + pledged + cat(state) + backers + cat(country) + usd pledged + usd_pledged_real + usd_goal_real");

/*
** Filter the data
*/
ks_projects = selif(ks_projects, ks_projects[., "launched"] .>= "2015");

The autogenerated code is printed to the Command window after import and is listed in the Command History. It can be copied and pasted for later use.

Cleaning Up Our Data

Now that we have loaded our data, let's get a better feel for our data. We'll do a few quick checks for common data problems such as:

• Duplicate observations.
• Missing values.
• Data misentries.

Viewing the Data

Let's open our ks_projects data in the Symbol Editor to confirm that it loaded correctly.

Checking for Duplicate Data

After loading my data, one of the first steps I take is to check for duplicate data. Duplicate data can distort results and should be eliminated before modeling.

GAUSS includes three functions, introduced in GAUSS 22, to address duplicate data:

As a preliminary check, let's see if our data has any duplicate ID observations:

// Check for unique ID numbers
isunique(ks_projects, "ID");

The isunique procedure returns 1.0000000 which tells us that our data is unique.

Checking for Misentries and Typos

Categorical and string data present the opportunity for errors in spellings, abbreviations, and more. It can sometimes be difficult to locate those errors in data.

The frequency procedure is a great way to check the quality of categorical variables.

Let's look at the frequency report for the country variable

// Check frequencies of countries
frequency(ks_projects, "country");

Label      Count   Total %    Cum. %
   AT        597    0.3196    0.3196
   AU       5385     2.883     3.202
   BE        617    0.3303     3.533
   CA       9679     5.181     8.714
   CH        760    0.4068     9.121
   DE       4171     2.233     11.35
   DK        996    0.5332     11.89
   ES       2276     1.218      13.1
   FR       2939     1.573     14.68
   GB      19889     10.65     25.32
   HK        618    0.3308     25.66
   IE        736     0.394     26.05
   IT       2878     1.541     27.59
   JP         40   0.02141     27.61
   LU         62   0.03319     27.64
   MX       1752    0.9379     28.58
 N,0"       3028     1.621      30.2
   NL       2081     1.114     31.32
   NO        633    0.3389     31.66
   NZ        994    0.5321     32.19
   SE       1589    0.8506     33.04
   SG        555    0.2971     33.34
   US     124533     66.66       100
Total     186808       100       

In this list, we see one odd category, N,0". However, given the frequency of this category, it's unlikely that this is a misentry and we probably don't want to remove this label.

It is reasonable though, that we remove the non-standard characters , and " from the label:

// Replace the N,0" with N_0 
ks_projects[., "country"] = strreplace(ks_projects[., "country"], "N,0\"", "N_0");

Now if we check our frequencies, we see our updated country label:

// Recheck frequencies of countries
frequency(ks_projects, "country");

Label      Count   Total %    Cum. %
   AT        597    0.3196    0.3196
   AU       5385     2.883     3.202
   BE        617    0.3303     3.533
   CA       9679     5.181     8.714
   CH        760    0.4068     9.121
   DE       4171     2.233     11.35
   DK        996    0.5332     11.89
   ES       2276     1.218      13.1
   FR       2939     1.573     14.68
   GB      19889     10.65     25.32
   HK        618    0.3308     25.66
   IE        736     0.394     26.05
   IT       2878     1.541     27.59
   JP         40   0.02141     27.61
   LU         62   0.03319     27.64
   MX       1752    0.9379     28.58
  N_0       3028     1.621      30.2
   NL       2081     1.114     31.32
   NO        633    0.3389     31.66
   NZ        994    0.5321     32.19
   SE       1589    0.8506     33.04
   SG        555    0.2971     33.34
   US     124533     66.66       100
Total     186808       100     

Generating New Variables

GAUSS dataframes make it easy to create new variables using existing variables, even with strings, categorical data, or dates.

Let's suppose we are interested in the impact that the amount of time between the campaign launch and deadline has on pledges. The raw data doesn't include any variable that measures the amount of time between launch and deadline.

Fortunately, GAUSS date handling and variable name referencing make it easy to create our variable.

// Create variable that measures total days between
// campaign launch and deadline
total_days = timeDiffPosix(ks_projects[., "deadline"], 
                           ks_projects[., "launched"], "days");

One important thing to note is that our new variable total_days is a standard GAUSS matrix, not a dataframe. We can use the asDF procedure to convert total_days to a GAUSS dataframe and add a variable name.

Let's do this and concatenate the new variable to our original data:

// Convert `total_days` to a dataframe
// and concatenate with original data
ks_projects = ks_projects ~ asDF(total_days, "Total Time");

When we open ks_projects in the Symbol Editor, we now see our new variable, Total Time, and its type listed in the variable list.

Getting to Know Our Data

Now that we've performed some preliminary data cleaning steps, it's time to get to know our data better with some simple data exploration.

Summary Statistics

Quick summary statistics give us insight into our data and can be helpful for finding outliers and other data abnormalities.

The dstatmt procedure allows us to compute descriptive statistics in a single line. It computes the following statistics:

• Mean
• Standard deviation
• Variance
• Minimum
• Maximum
• Valid cases
• Missing cases

There are a few things to note about the dstatmt procedure:

• Only the valid and missing observations are computed for string variables.
• Mean, Std Dev, and Variance are not computed for categorical variables. However, the minimum and maximum observations are computed based on the underlying key values.

Let's look at the summary statistics for our ks_projects data:

// Compute summary statistics
call dstatmt(ks_projects);

-------------------------------------------------------------------------------------------------
Variable                 Mean     Std Dev      Variance     Minimum     Maximum     Valid Missing
-------------------------------------------------------------------------------------------------
ID                  1.075e+09   6.189e+08     3.831e+17   1.852e+04   2.147e+09    186808    0
name                    -----       -----         -----       -----       -----    186807    1
category                -----       -----         -----       -----       -----    186808    0
main_category           -----       -----         -----         Art     Theater    186808    0
deadline                -----       -----         -----  2015-01-05  2018-03-03    186808    0
launched                -----       -----         -----  2015-01-01  2018-01-02    186808    0
pledged             1.192e+04   1.167e+05     1.361e+10           0   2.034e+07    186808    0
state                   -----       -----         -----    canceled   undefined    186808    0
backers                 114.1        1029      1.06e+06           0   2.194e+05    186808    0
country                 -----       -----         -----          AT          US    186808    0
usd pledged              6423   8.693e+04     7.557e+09           0   2.034e+07    183780 3028
usd_pledged_real    1.054e+04   1.084e+05     1.176e+10           0   2.034e+07    186808    0
usd_goal_real       6.052e+04   1.429e+06     2.041e+12        0.49   1.514e+08    186808    0
Total Time              32.71       11.61         134.7    0.005058       89.57    186808    0

One of the first things that stands out from these descriptive statistics is that there are a lot of missing observations of usd_pledged.

One solution for this, is to use usd_pledged_real and drop the usd_pledged_variable using the delcols procedure:

// Eliminate usd_pledged column 
// because of excess missing values
ks_projects = delcols(ks_projects, "usd pledged");

Statistics by Groups

Now, let's see how the mean of the variable usd_pledged_real varies across the variable main_category using the aggregate procedure.

// Find mean of `usd_pledged_real` across `main_category`
aggregate(ks_projects[., "main_category" "usd_pledged_real"], "mean");

   main_category usd_pledged_real
             Art        3472.4776
          Comics        6507.6264
          Crafts        1692.6939
           Dance        3344.5054
          Design        27245.928
         Fashion        5906.9240
    Film & Video        6065.4645
            Food        4736.2799
           Games        21032.577
      Journalism        2403.8985
           Music        3767.5486
     Photography        4571.2224
      Publishing        3792.7673
      Technology        20029.666
         Theater        3886.6224 

This is useful and we can see that there are clear differences in the mean amount pledged across project categories. However, it may be easier to see these differences if we sort our results using sortc:

// Sort aggregated data based on its second column, 
sortc(aggregate(ks_projects[., "main_category" "usd_pledged_real"], "mean"), 2);

   main_category usd_pledged_real
          Crafts        1692.6939
      Journalism        2403.8985
           Dance        3344.5054
             Art        3472.4776
           Music        3767.5486
      Publishing        3792.7673
         Theater        3886.6224
     Photography        4571.2224
            Food        4736.2799
         Fashion        5906.9240
    Film & Video        6065.4645
          Comics        6507.6264
      Technology        20029.666
           Games        21032.577
          Design        27245.928 

Now we can clearly see that the mean pledged amount is the lowest for Craft projects and is the largest for Design projects.

Exploring our Data with Visualizations

Data visualizations are one of the most powerful tools for preliminary data exploration. They can help us:

• Identify outliers and abnormalities in data.
• Find relationships between variables.
• Identify time-series dynamics.

All of these provide insights that can help guide modeling.

Unlike publication graphics, preliminary data visualizations for exploration don't need much custom formatting and annotation. Instead, it is more important that we can make quick and clear plots.

In GAUSS 22, plots were enhanced with intelligent graph attributes which make data visualization substantially easier and more useful, including:

• The ability to specify variables to plot by name with convenient formula strings.
• Automatic use of variable names and category labels.
• Data splitting using the new by keyword.

For example, let's see how the usd_pledged_real is related to the Total Time variable that we created using a scatter plot:

// Create scatter plot of `usd_pledged_real` against `Total Time` 
plotScatter(ks_projects, "usd_pledged_real ~ Total Time");

Our plot provides some quick data insights:

• The majority of campaigns are between 0-60 days in length.
• There appear to be clusters of campaigns around approximately 30, 45, and 60 days in length.
• There doesn't appear to be much of a correlation between campaign length and pledged dollars.
• The majority of campaigns earned less than 3e+06 and there are a lot of campaigns that didn't receive any pledges.

Based on the last observation, it might be useful to:

1. Filter out the observations that received no pledges (we won't address the topic of truncated data here and I'm not suggesting that this is in general a good modeling step)

// Filter out observations with no pledges
ks_projects = selif(ks_projects, (ks_projects[., "usd_pledged_real"] .!= 0));

1. Look at the percentiles usd_pledged_real using the quantile procedure:

// Create sequence of percentiles
e = seqa(0.1, .1, 10);

// Compute quantiles
quantile(ks_projects[., "usd_pledged_real"], e);

 quantile    usd_pledged_real
      0.1           12.000000
      0.2           51.720000
      0.3           151.00000
      0.4           390.60800
      0.5           896.00000
      0.6           1868.1440
      0.7           3664.7240
      0.8           7442.5860
      0.9           18309.240 

This is helpful, it tells us that 50% of usd_pledged_real observations fall below about $1,000, 80% fall below about $10,000 and 90% fall below about $19,000.

Given these observations let's look at histogram of the pledges that fall between the 10% and 50%:

// Filter our data to look at
// data between 10% and 50% 
ks_projects = selif(ks_projects, 
                   (ks_projects[., "usd_pledged_real"] .> 12 .and 
                    ks_projects[., "usd_pledged_real"] .< 1000));

// Histogram of remaining data
plotHist(ks_projects[., "usd_pledged_real"], 100); 

Conclusion

Data cleaning is tedious and time-consuming, but we've seen in this blog how the right tools and make it less painful. We've looked at how to efficiently prepare and explore real-world data before modeling or estimation including:

• Loading.
• Cleaning data to eliminate misentries, missing values, and more.
• Exploring data.

Categorical variables offer an important opportunity to capture qualitative effects in statistical modeling. Unfortunately, it can be tedious and cumbersome to manage categorical variables in statistical software.

The new GAUSS category type, introduced in GAUSS 21, makes it easy and intuitive to work with categorical data.

In today's blog we use real-life housing data to explore the numerous advantages of the GAUSS category type including:

• Easy set-up and viewing of categorical data.
• Simple renaming of category labels.
• Easy changing of the reference base case and reordering of categories.
• Single-line frequency plots and tables.
• Internal creation of dummy variables for regressions.
• Proper labeling of categories in regression output.

The data

Throughout today's blog, we will be using the Melbourne Housing Snapshot dataset.

The dataset contains the following variables:

Loading our Data

Let's start by loading our dataset using the GAUSS Data Import window:

When we open the dataset for loading we can see quickly from the color-coded columns what type GAUSS is assigning to our variables. For example:

• Type and Method (highlighted orange) are categorical variables.
• Suburb, Address, and SellerG (highlighted yellow) are listed as string variables.
• Rooms and Price (highlighted blue) are numbers.

Changing a Variable to a Category

Suppose that we also want the variable Suburb to be loaded as a categorical variable. This can be easily done using the Variables tab.

When we change the variable Suburb type to Category, the Modify Column Mapping window opens:

This window is very useful and gives us a number of insights. For example, from this window we can tell that:

• The category Abbotsford is the base case.
• All labels and category mapping.
• There are 314 different categories.

If we want to explore the categories more we can use the Label Filter:

Once we are done changing the type to category, if we click OK, the preview for Suburb is changed to Category with orange highlighting:

Importing our Data

Now that we've set Suburb to be a categorical variable, we're ready to load our data. Clicking Import loads our data and auto-generates the GAUSS code for all import steps.

Managing the Properties of Categorical Variables

One of the advantages of using the category type is that the category properties can be easily modified using the Data Management pane.

Changing Category Labels Interactively

Suppose that after loading our data, we realize that our current labels for the Type variable are not very clear. Instead, we wish to rename the labels such that :

Once we open the dataframe in the data editor, this is easy to do. We simply:

1. Select the Manage button to open the Data Management pane:
2. Click the drop-down button to the right of the variable name and select Properties to open the Modify Column Mapping dialog.
3. Enter the new label in the Renamed Label textbox next to the category label we want to change.

Let's use the same process to also change the category labels on for the Method variable:

Once we've done this, the variable names Type and Method are highlighted in red. This indicates that we have unsaved changes.

When we click Apply the changes are saved and the commands GAUSS uses to change the category labels are generated in the Program Input/Output window.

melb_data = setcollabels(move(melb_data), "House"$|"Townhouse"$|"Duplex unit", 0|1|2, "Type");
melb_data = setcollabels(move(melb_data), "Passed in"$|"Sold"$|"Sold after auction"$|"Sold prior auction"$|"Vendor bid", 0|1|2|3|4, "Method");

Changing the Base Case

When working with categorical variables, it is useful to know that GAUSS always treats the variable with the key value "0" as the base case. For example, we saw earlier that the base case for the Suburb variable was Abbotsford.

If you want to change the assigned base case (or otherwise reorder the categories), this can quickly be done using the Modify Column Mapping dialog.

For example, suppose we want to replicate a study that uses the category Chelsea as the base case. To do this we:

1. Locate and select the category Chelsea using the Label Filter
2. Use the Double Arrow button to move Chelsea to the top of the list.
3. Apply our changes.

Exploring our Categorical Variables

To dive deeper into our categorical variables we can use the dstatmt, frequency, and plotFreq procedures.

General Summary Statistics

First, let's get a general overview of our data, including the categorical variables, using the dstatmt function:

// Print descriptive statistics for all variables in 'melb_data'
call dstatmt(melb_data);

This prints a table of descriptive statistics to the Program Input/Output window:

----------------------------------------------------------------------------------------------
Variable              Mean     Std Dev      Variance     Minimum     Maximum     Valid Missing
----------------------------------------------------------------------------------------------

Suburb               -----       -----         -----     Chelsea  Yarraville     13580    0
Address              -----       -----         -----       -----       -----     13580    0
Rooms                2.938      0.9557        0.9135           1          10     13580    0
Type                 -----       -----         -----       House  Duplex uni     13580    0
Price            1.076e+06      639311     4.087e+11     8.5e+04       9e+06     13580    0
Method               -----       -----         -----   Passed in  Vendor bid     13580    0
SellerG              -----       -----         -----       -----       -----     13580    0
Date                 -----       -----         -----  28/01/2016  23/09/2017     13580    0
Distance             10.14       5.869         34.44           0        48.1     13580    0
Postcode              3105       90.68          8222        3000        3977     13580    0
Bedroom2             2.915      0.9659         0.933           0          20     13580    0
Bathroom             1.534      0.6917        0.4785           0           8     13580    0
Car                   1.61      0.9626        0.9267           0          10     13518   62
Landsize             558.4        3991     1.593e+07           0    4.33e+05     13580    0
BuildingArea           152         541        292697           0   4.452e+04      7130 6450
YearBuilt             1965       37.27          1389        1196        2018      8205 5375
CouncilArea          -----       -----         -----     Banyule  Yarra Rang     12211 1369
Latitude            -37.81     0.07926      0.006282      -38.18      -37.41     13580    0
Longitude              145      0.1039        0.0108       144.4       145.5     13580    0
Regionname           -----       -----         -----  Eastern Me  Western Vi     13580    0
Propertycount         7454        4379     1.917e+07         249   2.165e+04     13580    0 

Though traditional summary statistics aren't valid for categorical data, the descriptive statistics still provide some insights:

• The minimum category is always the base case for the variable.
• We can identify if there are any missing observations.

Frequency Table of Categories

The frequency procedure was introduced in GAUSS 21 specifically to provide frequency count tables. The procedure requires two inputs:

x

Data matrix or data frame.

varlist

String, names or indices of variables to be counted. If names, should be entered as a formula string e.g "rep78 + foreign".

---

To see frequency counts for both Method and Type in our dataframe melb_data we enter:

// Print frequency tables for the 'Type' and 'Method' variables
// in the 'melb_data' dataframe
frequency(melb_data, "Type + Method");

This prints the category names along with:

• Total counts.
• Frequency percentages.
• Cumulative percentages.

             Label      Count   Total %    Cum. %
             House       9449     69.58     69.58
         Townhouse       1114     8.203     77.78
       Duplex unit       3017     22.22       100
             Total      13580       100


             Label      Count   Total %    Cum. %
         Passed in       1564     11.52     11.52
              Sold       9022     66.44     77.95
Sold after auction         92    0.6775     78.63
Sold prior auction       1703     12.54     91.17
        Vendor bid       1199     8.829       100
             Total      13580       100    

Frequency Plot of Categories

The information provided with the frequency procedure can be quickly visualized using the plotFreq procedure.

For example, let's plot the frequencies for the Method variable:

plotFreq(melb_data, "Method");

Estimation with Categorical Variables

The final area we will explore today is the use of the GAUSS category type in estimation. Estimation of one of the areas that the GAUSS category type offers the greatest advantages.

GAUSS category variables can be used in estimation routines, such as olsmt or glm without taking any additional step.

When category variables are detected in estimation routines GAUSS will automatically:

• Create and use dummy variables during estimation.
• Exclude the base case category.
• Print output tables using specified category labels.

As an example, let's run a simple linear regression model estimating the role of Method, Bedroom2, and Bath on Price:

call olsmt(melb_data, "price ~ method + bedroom2 + bath");

                                           Standard                 Prob   Standardized  Cor with
Variable                       Estimate      Error      t-value     >|t|     Estimate    Dep Var
-------------------------------------------------------------------------------------------------

CONSTANT                        59797.1     20407.1     2.93022     0.003       ---         ---

Method: Sold                    40895.7     14857.5     2.75252     0.006   0.0302079   0.0256233
Method: Sold after auction     -54790.4     57921.6    -0.94594     0.344 -0.00703034  -0.0064481
Method: Sold prior auction      -109114     18989.1    -5.74614     0.000  -0.0565257   -0.104125
Method: Vendor bid              77144.6     20737.2      3.7201     0.000   0.0342371   0.0442128
Bedroom2                         202813     5924.64     34.2321     0.000    0.306426    0.475951
Bathroom                         263854      8314.3      31.735     0.000    0.285481    0.467038 

Notice that the results include estimated coefficients for each of the Method categories, except the base case, Passed In.

Conclusion

Today we've seen how fast and easy it can be to work with categorical variables using the new GAUSS category type. Whether you're just getting started exploring your data or you're in the final stage of estimation, the category type can speed up your work and get you to your results faster.

Further reading

1. Introduction to Categorical Variables.
2. Easy and Fast Data Management in GAUSS 21 .
3. Preparing and Cleaning FRED data in GAUSS/

The FRED data repository provides access to a wide variety of economic time-series data. It is widely used in research across a number of fields including social sciences, economics, and finance.

FRED provides extensive access to data. However, that data must be pre-processed and properly cleaned before usage. This can be a time-consuming and tedious part of data analysis.

In today’s blog, we look at how to save time and reduce errors using GAUSS’s new data management tools.

Using the quarterly real GDP dataset from the FRED database we explore GAUSS’s new data management tools.

In particular, we examine how to:

• Deal with irregular dataset headers.
• Change variable names.
• Filter dates and change the date display.

Simple Data Import Example

The real GDP series from the FRED database was downloaded and is stored in the file fred_rgdp.xlsx. To start, we open our dataset in the Data Import window by double-clicking on the filename, fred_rgdp.xlsx in the Project Folders tab.

This opens the Data Import tool:

The data preview window indicates that there are a number of issues to address in our raw dataset:

• The raw data includes an irregular header.
• The variable names are not correct.

Updating the header row

We can see in our data preview that more appropriate variable names are located row 11. This can be specified using the Header Row text box on the Import Options tab:

The variable names are automatically updated in the preview to reflect the names contained in row 11. Also notice that the Row Range input is automatically updated to 12, one past the header row.

Importing data

The FRED real GDP data is now ready for import and we can select Import to bring the data into the GAUSS workspace.

Note that when we do, the GAUSS code used to import the data is auto-generated and can be used to replicate the interactive steps we performed.

The auto-generated code can be accessed a few different ways:

1. The command history. To send the code from the command history to a file, right-click on the command in the History list and select Send to File.
2. The Program Input/Output window. The code snippet can be directly copied by selecting the code snippet, right-clicking, and selecting Copy.

Cleaning Data in Memory

Suppose that after importing the real GDP data, we decide we want to perform some data cleaning steps.

Specifically, let’s consider performing the following:

• Changing the name of the GDPC1 variable.
• Changing the display format of the observation_date.
• Filtering by date to only include observations from 1970 or later.

To begin, double-click fred_rgdp in the Symbols window on the left to open it in the symbol editor.

Changing a variable name

To change a variable name, click the triangle next to the GCPC1 variable name to open the Variable settings menu and select Rename:

Enter the new variable name, real_gdp, in the Rename Column dialog box and select OK:

Changing the date display format

The observation dates for our quarterly data, contained in observation_date, are currently displayed in the ISO-8601 (“Year-Month-Day”) format (1947-01-01). Since we are working with quarterly data, let’s update this to display the year and quarter, 1947-Q1.

This can be done by expanding the Variable settings menu for observation_date and selecting Properties. This opens the Specify Date Format dialog:

We enter our new date display format, %Y-Q%q, in the Date Display text box and click OK.

The data editor preview now shows:

The asterisk on the matrix name tab indicates that our dataframe fred_rgdp has unsaved changes.

Filtering dates

To finish our real GDP FRED data cleaning example, let's filter the dataframe to include only observations that occur in 1970 and later.

To do this, select the Filter tab and set:

1. The Variable equal to observation_date (this is the default).
2. The Operation to >=.
3. The Value equal to 1970-01-01.

After setting all three parts of the filter, we click the + button to add the filter. When we do this, the data preview updates to indicate which values will be included after hitting Apply:

Conclusion

The first, and least glamorous, step in successful data modeling is data cleaning -- the quality of any model depends on the quality of the data coming in.

Today, we’ve examined how the interactive data management tools in GAUSS can make this process less painful and less tedious.

Specifically, we’ve seen how to interactively:

• Remove irregular headers.
• Change variable names.
• Filter by date.
• Change a date display format.

Further reading:

• For a complete guide to the GAUSS data management, check out our online Data Management Guide.
• The blog, Easy and Fast Data Management in GAUSS 21 provides an overview of all the new GAUSS 21 data management tools.
• For a video example of the data management tools, see our latest YouTube video, Quick and Easy Interactive Data Cleaning

You probably know that you can use GAUSS code to create repeatable styling for your graphs. However, you might not know that GAUSS also allows you to build reusable graphics profiles with a few clicks of your mouse.

We will show you how to clone existing graphics profiles and how to control:

• Font settings for the title, axes labels, and tick labels.
• Line colors and styles.
• Legend location and styling.

While this tutorial will not cover all available options, you should learn enough to be comfortable making most other changes without additional help.

Our Project

For this tutorial, our goal will be to create a graph profile to replicate the style of the graph below. Data for the graph can be downloaded from here.

Video Tutorial

This video tutorial will show you how to:

1. Clone an Existing Graph Profile.
2. Modify Title and Axis Font Settings.
3. Modify Line Style and Legend Descriptions.
4. Set the Legend Properties.
5. Set the Y-axis Label.

or read the text instructions below.

Step 1: Clone an Existing Graph Profile

1. Select Tools > Preferences from the main GAUSS menu.
   
2. Select Graphics on the left side of the Preferences window.
   
3. Select the Profiles button at the top of the Graphics Preferences.
   
4. Select the profile you would like to clone from the dropdown list.
   
5. Select the Clone button.
   
6. Enter the name for your new profile and click OK.
   

Step 2: Modify Font Settings

Set the Title Font

Using the graphics profile created in the previous step:

1. Select Title from the list of graph settings on the left.
   
2. Click Change button on the right.
   

This will open your operating system's font dialog, where you can select your desired font, weight, and size:

Set the Axes Label and Tick Label Fonts

1. Select Axes Style from the list of graph settings on the left.
   
2. From the Caption section, select the Change button to modify the axes label font.
   
3. Click the Numbers Change button and select your preferred font settings for the tick labels.
   

Step 3: Modify Line Style and Legend Descriptions

We'll start by modifying the third line which marks the date of the first U.S. location transmission.

1. Select Series 3.
2. Enter the legend text for this line in the Legend Title text input box.
3. Double-click the color box next to Line Color and select a gray color.
4. Select Dash Line from the dropdown box next to Style.

Then repeat step 2 above to add the legend text for Series 1 and Series 2.

Step 4: Set the Legend Properties

1. Select Legend.
2. Click the font Change button and set the desired font and font size.
3. Select the legend location, using the Vertical Position, Horizontal Position, Inside/Outside and Orientation options.
4. Double-click the color box next to Line Color and set it to white so the legend outline is unseen.

Step 5: Set Y-axis Label

1. Select Axes Text.
2. Enter the desired axis label in the appropriate text box.

Use the Custom Graphics Profile

You can access the settings from a graph profile using the plotGetDefaults function as you would for the default settings. Below is a simple example.

// Load variables
Y = loadd("cook-county-covid.csv", "cases + deaths");

x = seqa(1, 1, rows(Y));

// Declare myPlot to be a plotControl structure
// and fill with the settings from our covid profile
struct plotControl myPlot;
myPlot = plotGetDefaults("covid");

// Draw plot using covid profile settings
plotXY(myPlot, x, Y);

which will produce the plot below:

Further Customize

While the graphs for a given project may share many features, it is likely that some attributes such as the title or legend text will need to be different. You could clone your custom profile and make these changes. However, it might be simpler to make these changes in your code.

Fortunately, you can use the plotSet functions to further customize the settings for a particular graph. You can modify any settings that you would like to change.

The code below shows how to change the title, keeping all other settings unchanged.

// Load variables
Y = loadd("cook-county-covid.csv", "cases + deaths");

x = seqa(1, 1, rows(Y));

// Declare myPlot to be a plotControl structure
// and fill with the settings from our covid profile
struct plotControl myPlot;
myPlot = plotGetDefaults("covid");

// Set title text
plotSetTitle(&myPlot, "COVID-19 Cook County");

// Draw plot using covid profile settings
plotXY(myPlot, x, Y);

These settings will not modify the custom graphics profile that you created. Next time you call myPlot = plotGetDefaults("covid"), myPlot will be filled with the custom profile settings that you selected in the Preferences dialog window.

Full Code for Time Series Plot

Full code to create the time series plot shown at the top of this post, using the "covid" custom graphics profile we created, can be downloaded here.

Conclusion

Great job! You've learned how to interactively create custom graphics profiles that can be easily reused and further modified.

Next Steps

• How to Mix, Match and Style Different Graph Types.
• Five Hacks For Creating Custom GAUSS Graphics.
• Graph high-frequency Forex data.

You're probably familiar with the basic find-and-replace. However, large projects with many files across several directories, require a more powerful search tool.

The GAUSS Source Browser is the powerful search-and-replace tool you need. We'll discuss some ways you can use it to make your life easier, including:

1. How to find all usages of a function or variable in a file with two clicks.
2. How to perform searches across multiple files and directories.
3. Advanced search options, such as how to find only variable assignments.
4. How to replace search terms across files and directories.

How to View All Uses of a Variable or Function

If an output seems incorrect or is causing an error, you need a quick way to trace the progress of specific variables. GAUSS's Find Usages functionality does exactly that.

Find Usages Basics

As shown in the image below, right-click on the variable you want to search for and select Find Usages.

This will search our current file for every instance of our search variable and display them in the GAUSS Source Browser.

As we can see in the above image, Find Usages has shown us:

1. The name and full path of the file.
2. The full line of code containing our search term, which:
   • Starts with the line number.
   • Highlights our search term.

We can double-click on a line in the Source Browser to open it in the GAUSS editor.

How to Search Across Directories

The Find Usages basics alone are great, but the GAUSS Source Browser has much more to offer.

How to Open the Source Browser

In addition to right-clicking and selecting Find Usages, the Source Browser can be opened two ways:

1. Select View > Source Browser from the GAUSS main menu.
2. Use the Ctrl+Shift+F (Command+Shift+F) keyboard shortcut.

Basic Multi-file Search

The Search Tab

The Search Tab is the starting point for any search. It has three input boxes:

1. Search for accepts your search query.
2. File pattern allows you to restrict your search to specific file types.
   • The default search pattern is *.*, where * is a wildcard character that will match any character or characters.
   • You can add a comma-separated list of files, or file types to match. For example: *.gss, estimate.src.
   • Click the downward-pointing arrow at the end of the File pattern box to bring up a list of common GAUSS file extensions, such as *.gss,*.src,*.sdf,*.gau,*.prg.
3. Directory specifies the location to search.
   • The default options from the dropdown-list are:
     • Current working directory.
     • GAUSS Search Paths.
     • Project View Locations.
     • Current File.
   • You can also enter the name of any file or folder on your computer.

Executing the search

Using these tools together can help us quickly locate the information we're looking for. For, example, suppose we want to find uses of the GAUSS generalized method of moments procedure, gmmFit, in internal GAUSS source code.

We can achieve this by:

1. Entering gmmFit in the Search for box.
2. Entering /Users/Research/gauss/src as our Directory.
3. Selecting the Search button.

We could also set the File pattern option to *.src to limit our search to .src files. However, we left the default option to search all files in this case.

Our search results show that the term gmmFit is used between 1 and 37 times in each of five files in the specified directory.

Advanced Search Options

The Advanced Tab

The Advanced Tab provides many useful options for further refining our search. We'll discuss some of the most helpful and less common options.

How to Find Variable Assignments

The Assignments checkbox allows us to restrict our search to only the instances when a variable is assigned to. Narrowing the list of uses to assignments only is invaluable when tracking down the cause of an incorrect value. The screenshot above shows our original Find Usages search after adding the Assignments filter.

References is the opposite of Assignments, returning instances where a variable is used, but not assigned to.

How to Search Subdirectories

By default, the Source Browser will search the directory that you specify and all subdirectories. Uncheck the Search Subdirs checkbox to restrict the search to the main search directory only.

How to Replace Across Directories

The Replace Tab

Executing a Replace Across Multiple Files

After we have completed our desired search, we can perform our replace by:

1. Selecting the Replace tab in the Source Browser window.
2. Entering the new term in the Replace box.
3. Clicking the Replace button.

Advanced Multi-file Replace Options

The checkboxes at the start of each line of the search results allow you to quickly control which results are replaced.

Backup Original will create a copy of your files with a .bak file extension before making the replace. Since there is no undo option for replacements made to files not open in the editor, the .bak copies allow you to recover the original file if you make a mistake.

Overwrite Backup will copy over any pre-existing .bak files made by previous searches with Backup Original selected. If this option is unchecked, GAUSS will use .bak2, .bak3, etc if pre-existing .bak files are found.

Conclusion

After reading this post, you now know how to use the advanced search and replace tools in GAUSS to be more productive!

We have learned:

1. How to quickly search your current file with Find Usages.
2. How to find the exact code you need to see across multiple files and directories.
3. How to find only variable assignments or variable references.
4. How to replace search terms across files and directories.

The GAUSS Package Manager, first introduced in version 20, allows you to download, install and uninstall GAUSS packages without leaving GAUSS.

It supports the paid GAUSS Application Modules, free GAUSS packages and even allows you to create custom packages and channels.

This post will guide you through the basics needed to install and uninstall GAUSS packages.

Install the Package Manager

The Package Manager must be downloaded and installed before its first use. To begin this process, select Tools > Package Manager from the main GAUSS menu. This will open a window which looks like this:

For complete instructions on installing the Package Manager see our online video:

The Installation Directory

By default, the Package Manager will install inside a folder named conda inside your GAUSSHOME folder. In most cases, you should leave the default installation directory.

However, the initial release of the Package Manager does not support installation directories with spaces in the path names. If your GAUSSHOME directory contains a space, you will need to point this to another folder in which your user has write permissions.

Download Account Credentials

The next section is for your GAUSS Download Account username and password. This allows you to download any GAUSS Application Modules which you have purchased. If you do not know your username and password, contact Aptech.

A username and password are not required to download free packages.

Install

Click the install button on the bottom right of the Install Package Manager window. This will begin the download and installation of the Package Manager. It will take a minute or two. When the installation has completed you will see the following pop-up window.

How to Install a GAUSS Package

If you have not already installed the Package Manager, see the previous steps.

1. Select Tools > Package Manager to open the Installed Packages window shown below:
   As the name implies, it will list all the packages you have previously installed. If you have not installed any packages, the window will be blank as we see above.
2. Click the plus icon (+) on the top right of the Installed Packages window to open the Repository Packages window.
3. Click the name of an available package from the list in the Repository Packages window.
4. Click the Install Package button on the bottom-left.
5. Click Close when the package has finished installing.

Package Install FAQ

Why are some of the packages locked?

If a package in the Repository Packages window has a red background color, it means that the username and password you have entered do not allow access to the package.

How can I reset my username and password?

1. Open the Repository Packages window:
   • Select Tools > Package Manager from the main GAUSS menu.
   • Then select the plus icon (+) on the right of the Installed Packages window.
2. Click the Settings button.
3. Enter your username and password in the appropriate boxes and click OK.

How to Uninstall a GAUSS Package

1. Select Tools > Package Manager from the main GAUSS menu.
2. Click the name of the package to uninstall.
3. Select the uninstall (-) icon.

Conclusion

In this post, you've learned:

1. How to install the GAUSS Package Manager.
2. How to use the GAUSS Package Manager to install and uninstall GAUSS packages.
3. How to reset your username and password.

Further Reading

1. Using GAUSS Packages [Complete Guide]
2. Understanding Errors | G0025 : Undefined symbol
3. GAUSS Basics 2: Running a program

Whether you are new to GAUSS, or have been around for a while, today's blog will have something for you.

We'll answer the questions:

• What is the current working directory in GAUSS?
• How can I find my working directory?
• How can I change my working directory?

Then we'll show you how some common GAUSS functions use your working directory and some of the errors you're most likely to run into.

What is the GAUSS Current Working Directory?

In GAUSS, the working directory is the default search location for any function, procedure or command that works on files. This includes:

• Functions that read and write data.
• The #include and output commands.
• deleteFile and renameFile.
• The run, edit and debug commands.

How can I find my current working directory?

User Interface

The Working Directory Toolbar Widget located on the main GAUSS toolbar, displays the current working directory.

Commands

Pass a zero to the cdir command to print out your current working directory as shown below.

// Print a string containing your current working directory
cdir(0);

How can I set my current working directory?

User Interface

1. Click the button with three horizontal dots, ..., on the right of the working directory widget to browse and select a new folder.
   
2. Click on the name of the current working directory to bring up a list of recent working directories.
3. Set your working directory to a folder open in your Project Folders Window by right-clicking the name of the folder and selecting Set to Working Directory.
4. Right-click on the tab of an open file to change your working directory to the location of that file.

Commands

Pass a literal path, or a string prepended with the caret operator, ^, to the chdir keyword to programmatically change your working directory.

/*
** Change your working directory using a literal path
*/

// Windows
chdir C:\gauss;

// macOS
chdir /Users/gauss;

/*
** Change your working directory using a string containing the path.
** Note the use of the caret operator, '^'.
*/

// Windows
new_path = "C:\gauss";
chdir ^new_path;

// macOS
new_path = "/Users/gauss";
chdir ^new_path;

Applications and common errors

Now that we've learned a little about the GAUSS working directory as well as several ways to check it and set it, we'll go over some cases where your working directory needs to be set correctly. We'll also discuss the errors that you'll encounter if it is not.

Loading data

The data loading functions in GAUSS only search one folder for the data file.

Fully pathed file names tell GAUSS exactly which folder to search for the data file. For example:

// Load the 'price' variable from the file 'auto2.dta'
// located in the folder C:\gauss
auto_prices = loadd("C:\\gauss\\auto2.dta", "price");

File names without paths tell GAUSS to search for the file only in the current working directory.

// Load data from the file 'nba_ht_wt.xlsx'. Since there is
// no path, look for the file only in the current working directory.
height = xlsReadM("nba_ht_wt.xlsx", "C2:C10");

Errors

If you run the above code, but the nba_ht_wt.xlsx file is not in your current working directory, you will get the error:

Error in xlsReadM: file '/Your/cwd/nba_ht_wt.xlsx' not found [xls.src, line 953]

assuming your current working directory was /Your/cwd. While this error message is pretty clear about the problem, sometimes (especially when running someone else's code) the error message might come from an advanced or internal function. Below are a few that you may run into.

Filename not found: my_data_file.dta

Error in xlsGetSheetSize: file '/Your/cwd/my_data_file.xlsx' not found
[xls.src, line 953]

G0122 : Bad file handle [formula_parse.src, line 635]

G0014 : File not found 'my_data_file.fmt'

We'll discuss some of these errors in future blog posts, but one key thing to notice is that if GAUSS is looking in your current working directory, it will either mention the file with your current working directory, or the file with no path at all.

#include

The #include command is seen in quite a bit of public GAUSS code. You can find an entire post dedicated to #include here.

For our purposes, we only need to mention a couple of things. A #include statement without a path, like this:

#include my_procs.src;

will search for my_procs.src in:

1. Your current working directory.
2. The folders in your SRC_PATH.

Errors

If GAUSS cannot find a file referenced in a #include statement like the one above (i.e. without a path), the error message will look something like this:

G0014 : File not found 'C:/gauss/pkgs/tsmt/src/my_procs.src' [my_code.gss, line 8]

The path in the error message will be the last folder where GAUSS looked for the file. This will correspond to the last entry in your SRC_PATH. It does not mean that GAUSS only looked in that folder.

Run, edit and debug

The run, edit and debug commands look for files in the same location as #include.

run my_program.gss

1. Your current working directory.
2. The folders in your SRC_PATH.

Errors

If you try to run or debug a file that is not in your current working directory or your SRC_PATH, the error will simply state:

G0014 : File not found 'my_program.gss'

A current working directory alternative

While it is common to reference files without a path in the ways that we have seen above, it is not necessarily the best practice.

The GAUSS __FILE_DIR command allows you to set up code projects that will work on any computer without changing path references or your working directory. Read more about __FILE_DIR.

Conclusion

Congratulations! You've learned:

1. That your current working directory is the first place that all GAUSS functions will look for a file when a path is not specified.
2. How to find and set your current working directory.

as well as some information about a few of the functions which use the current working directory and their error messages.

GAUSS includes a plethora of tools for creating publication-quality graphics. Unfortunately, many people fail to use these tools to their full potential. Today we unlock five advanced GAUSS hacks for building beautiful graphics:

1. Using HSL, HSLuv, and Colorbrewer color palettes.
2. Controlling graph exports.
3. Changing the plot canvas size.
4. Annotating graphs with shapes, text boxes, and lines.
5. Using LaTeX for GAUSS legends, labels and text boxes.

Using custom color palettes

GAUSS color schemes include 30 built-in color palettes designed for optimal visual impacts. These include pre-made palettes for sequential, quantitative and diverging data and colorblind friendly palettes.

If you can't find the pre-made palette you like, you can create your own evenly spaced colors in HSL hue space, evenly spaced circular hues in the HSLuv system, or blend custom color palettes.

Color palettes can be controlled using a number of GAUSS procedures:

As an example, let's look at getting the first three colors from the ColorBrewer Dark2 color palette:

// Get the first 3 colors from the ColorBrewer 'Dark2' palette
clrs = getColorPalette("Dark2", 3);

The resulting colors are:

Once the color palette is set, we can use these colors in GAUSS graphs for the line, background, or bar colors.

For example, to use our color palette to plot different colors for each series in a bar graph we would use plotSetFill to change the color assignment in our plotControl structure:

// Declare plotControl structure
struct plotControl myPlot;

// Initialize plotControl structure
myPlot = plotGetDefaults("bar");

// Set all bars to have a solid fill with the colors
// assigned to 'clrs' in the previous code box
textures = 1;
plotSetFill(&myPlot, textures, 1, clrs);

// Create data
x = seqa(1, 1, 5);
y1 = { 1.5, 2, 3, 0.5, 1 };
y2 = { 3, 6.7, 8, 2, 0.49 };
y3 = { 2, 3.4, 2.4, 1, 3 };

// Draw bar graph
plotBar(myPlot, x, y1~y2~y3);

Bar graph with Colorbrewer 'Dark2' color palette.

Controlling graph exports

Our second hack, the GAUSS plotSave procedure, is a handy tool which allows us to control the file type, size, and dots per inch (DPI) of exported graphs in a single command.

plotSave(filename, size); 
plotSave(filename, size, units);
plotSave(filename, size, units dpi);

The procedure is easy to use and has two required inputs and two optional inputs:

filename

String, name of the file to create with a file type extension. Available file extensions include: .jpg, .plot, .png, .pdf, .svg, .tiff.

size

2x1 vector, dimensions of the saved graph in specified units. The default unit is centimeters.

units

Optional input, String, type of units dimension is specified in. Valid options include:
    "cm" Centimeters (Default)
    "mm" Millimeters
    "in" Inches
    "px" Pixels

dpi

Optional input, scalar, requested dots per inch when saving file. Defaults to current system DPI. dpi determines the number of pixels rendered when saving a file in terms of physical dimensions (cm, mm, in).

---

For example, if a publisher requests a 640 x 480 pixel .png plot, we specify:

// Save the graph as a 640 wide by 480 tall PNG file
plotSave("mygraph.png", 640 | 480, "px");

However, if we need an 11 x 8.5 inch PDF at 300 DPI for a flyer, we specify:

// Save the graph as a 11 x 8.5 inch PDF at 300 DPI
plotSave("mygraph.pdf", 11 | 8.5, "in", 300);

There are some helpful things to note about the plotSave procedure:

• The size input is a required input for all file types except .plot files.
• The unit input is ignored if the file is a .plot file.
• The dpi input determines the number of pixels rendered when saving a file in terms of physical dimensions (cm, mm, in). Specifying the dpi parameter has no effect if the specified units are pixels (px).

Changing the plot canvas size

There may be times when we want to see how a graph looks at a different size before we export it. This can be easily done with our next tool, plotCanvasSize.

The GAUSS procedure plotCanvasSize adjusts plot canvas sizes programmatically based on specifications in centimeters, millimeters, inches or pixels.

To produce our graph on a 750 px by 350 px canvas, as shown above, we place the call to plotCanvasSize prior to calling our graphic procedure:

/*
** Make this call before your plot to set the graph canvas
** to 750 px by 530 px as shown in the image above
*/
plotCanvasSize("px", 750|530);

When we are ready to go back to the default canvas size when simply tell GAUSS to "fill" the plot canvas:

// Go back to factory canvas size
plotCanvasSize("fill");

Annotating graphs with shapes, text boxes, and lines

Annotations make graphs more professional, more readable and easier to interpret. There are three easy-to-use functions for adding annotations to any existing GAUSS plot:

To create annotations there are a few key things to remember:

• The location of an annotation is specified using starting, and when applicable ending, x and y coordinates.
• We can use default settings for annotations or we can customize the appearance using the optional plotAnnotation structure.
• If we plan on using our annotations often and want to use the same styling, instead of going through multiple steps to set up the style each time, we can create a simple procedure to do the set up:

/*
** Add the procedure below to your user library
** and you will only need one line for all the settings
*/
plotAddTextbox(grayTextSettings(), "My customized text box", 0.15, 0.2);

proc (1) = grayTextSettings();
    struct plotAnnotation mytextbox;

    mytextbox = annotationGetDefaults();
    annotationSetBkd(&mytextbox, "#DDDDDD", 0.3);
    annotationSetFont(&mytextbox, "times", 18, "#555555");
    annotationSetLineThickness(&mytextbox, 2);
    annotationSetLineColor(&mytextbox, "#555555");
    retp(mytextbox);
endp;

Using LaTeX for GAUSS legends, label and text boxes

LaTeX is a powerful tool for generating scientific and technical documents because of its flexibility and ability to transcribe mathematical functions. GAUSS allows users to use the MathJax library for the interpretation of a wide variety of LaTeX commands.

To use LaTeX, we must first set the GAUSS text interpreter to ‘latex’ using the plotSetTextInterpreter procedure. This procedure requires three inputs:

&myPlot

A plotControl structure pointer.

interpreter

String, "html", "plain", "latex".

location

String, "all", "legend", "title" or "axes". Default is "all".

For example, let's use LaTeX for our legend, axes, and title:

new;

// Declare plotControl structure
struct plotControl myPlot;

// Initialize plotControl structure
myPlot = plotGetDefaults("xy");

// Set up text interpreter
plotSetTextInterpreter(&myPlot, "latex", "all");

We can now use LaTeX syntax for labeling our graph:

// Set up legend in LateX format
string legend_string = {
"y_1 = \\cos{(x)}",
"y_2 = \\sin{(\\frac{x}{2})} = \\pm \\sqrt{\\frac{1-\\cos{(x)}}{2}}",
"y_3 = \\cos{(\\frac{x}{2})} = \\pm \\sqrt{\\frac{1+\\cos{(x)}}{2}}" };

plotSetLegend(&myPlot, legend_string, "bottom right inside",1);

There are a few things to remember when using LaTeX in GAUSS:

1. Since backslashes are used for escape sequences in strings, you must use double backslashes.
2. Strings interpreted as LaTeX are automatically in ‘inline equation mode’. Therefore to add regular text, you must enclose the text inside of \text{ }. For example:

   /*
   ** Since LaTeX does not respect spaces inside of equations
   ** add a space after 'equation is' inside of the text section
   */
   "\\text{The equation is } \\alpha + \\beta X"

3. Text inside of a '\text{}' section will use the font set by the user as it would if the text interpreter were set to plain or HTML.

   /*
   ** 'Posterior distribution' will be in Times 24 point font
   ** The greek lambda will be proportional in size to Times 24, but will be in TeX font
   */
   plotSetTitle(&myPlot, "\\text{Posterior distribution of  } \\lambda_1", "Times", 24);

Conclusion

GAUSS graphics tools have been created with the end goal of generating publication quality graphs. In this blog we highlight five advanced hacks for raising the bar on your custom GAUSS graphics:

1. Using HSL, HSLuv, and Colorbrewer color palettes.
2. Controlling graph exports.
3. Changing the plot canvas size.
4. Annotating graphs with shapes, text boxes, and lines.
5. Using LaTeX for GAUSS legends, labels and text boxes.

For more tips and graph examples, please see our GAUSS plot library.

This video will guide you through:

• Creating folders for a GAUSS project.
• Opening your code in the Project Folders Window.
• Running the code.
• The Applications Installer.
• Setting your working directory.
• Error G0290 Library not found.
• Error G0014 File not found.
• Viewing workspace variables.

Next: Running Public GAUSS Code: Part 2