alert('The QScript is stopped!  Click OK to continue.');

if (askYesNo('Do you like green?'))
    log('User likes green.');

assert(project.dataFiles[0].getVariableByName('Q3') != null);

if (confirm('Do you want to show an alert?'))
    alert('Alert!');

includeFile('Utilities.QScript');

includeWeb('Utilities for Selecting Variables');

log('My QScript was here.');

var name = prompt('Enter you name:');

var indices = selectMany('What have you had today?', ['Breakfast', 'Lunch', 'Dinner']);
log('User has eaten '+indices.length+' meals.');

var animal_index = selectOne('What is your favourite?', ['Dog', 'Cat', 'Bird']);

 // Display a ^ marker in any cells that are in the column
// which represent our target market - people aged 18 to 29.

var target_column_labels = ['18 to 24', '25 to 29'];
for (var i = 0; i < target_column_labels.length; i++) {
    var column = table.columnIndex(target_column_labels[i]);
    // Confirm that the column index was found.  If not found, the index will be -1.
    if (column != -1) {
        // Yes, it was found.  Now go through each row in the column,
        // adding the footnote marker.
        for (var row = 0; row < table.numberRows; row++)
            table.addFootNote(row, column, '^', null, '^ This is our target market');
    }
}

 // When any cell has a Column n of less than 20, add a marker and footnote.
table.addFootNoteForCellsLessThan('Column n', 20, '**', '** sample size < 20');

 // When the sample size of a column is less than ten, make the cells in the column blank.

// Get column sample sizes.
var column_ns = table.get('Column n');

// Store the extra footnotes we generate for each blank column.
var extra_footers = table.extraFooters;

// Look at each cell.
for (var column = 0; column < table.numberColumns; column++) {
    // Get the sample size for this column (from the cell in the first row).
    var column_n = column_ns[0][column];
        
    // If the column's sample size is less than 10, make each cell in the column blank.
    if (column_n < 10) {
        for (var row = 0; row < table.numberRows; row++)
            table.blankCell(row, column);
        
        // Also, add a footnote that explains why some columns are missing.
        extra_footers.push('Column "' + table.columnLabels[column] + '" is blank because less than 10 people were asked the question.');
    }
}

// Set the extra footnotes.
table.extraFooters = extra_footers;

 // Change all arrows to full height, so their size does not vary by p value.
// This makes them easier to see without glasses.
table.requireNumericTable();
var arrows = table.cellArrows;
table.rowIndices(true).forEach(function (row) {
    table.columnIndices(true).forEach(function (column) {
        if (arrows[row][column] > 0)
            arrows[row][column] = 1;
        else if (arrows[row][column] < 0)
            arrows[row][column] = -1;
    });
});
table.cellArrows = arrows;

 // Color each cell that represents our client's brand in red.
 
 var coke_row = table.rowIndex('Coca Cola');
 if (coke_row != -1) {
     // There is a Coca Cola row here!
     
     // Fetch the array of cell colors (one entry for each cell).
     var colors = table.cellColors;
     
     // For all cells on this row, set the color.
     for (var column = 0; column < table.numberColumns; column++)
         colors[coke_row][column] = 'OrangeRed';
         
     // Store array of cell colors we just modified.
     table.cellColors = colors;
 }

 // Color yellow any cell that a p-value of less than 5%.
 
 // Get p-values array.
 var ps = table.get('p');
 
 // Get the cell colors array.
 var colors = table.cellColors;
 
 // Look at each cell...
 for (var row = 0; row < table.numberRows; row++)
     for (var column = 0; column < table.numberColumns; column++) {
         // Get the cell's p-value.
         var p = ps[row][column];
         // If the value is less than 5%, color this cell yellow.
         if (p < 0.05)
             colors[row][column] = 'yellow';
     }
 
 // Store the modified cell colors.
 table.cellColors = colors;

 // Turn the table into a "heat map", which represents the
 // scale of values by color - low values are blue (cold)
 // and high values are red (hot).
 //
 // The first statistic on the table is used for the scale of values.
 // 
 // To test this example, open the Cola.Q example project and
 // add the example to any table.
 
 // Get the name of the first statistic.
 var first_statistic = table.statistics[0];
 
 // Get the first statistic's values.
 var values = table.get(first_statistic);
 
 // Some cells should be ignored.
 var ignore_rows = [];
 var ignore_columns = [];
 if (first_statistic == 'Column %')
    ignore_rows.push(table.rowIndex('NET'));
 else if (first_statistic == 'Row %')
    ignore_columns.push(table.columnIndex('NET'));
 
 // Calculate the minimum and maximum values.
 var min, max;
 for (var row = 0; row < table.numberRows; row++)
    for (var column = 0; column < table.numberColumns; column++)
        if (ignore_rows.indexOf(row) == -1 && ignore_columns.indexOf(column) == -1) {
            var value = values[row][column];
            if (min == null && max == null) {
                min = value;
                max = value;
            } else {
                min = Math.min(min, value);
                max = Math.max(max, value);
            }
        }
 
 // Get the array of cell colors (currently blank, or white).
 var cell_colors = table.cellColors;
 
 for (var row = 0; row < table.numberRows; row++)
    for (var column = 0; column < table.numberColumns; column++)
        if (ignore_rows.indexOf(row) == -1 && ignore_columns.indexOf(column) == -1) {
            var value = values[row][column];
            
            // Get the current value as a scale proportion (0-1)
            var scale = (value - min) / (max - min);
            
            // Make sure the current value is not missing data or infinity,
            // which could arise if there is insufficient data on the table...
            if (!isNaN(scale) && isFinite(scale)) {
                // Create a color to represent where this value fits on the scale.

                // covertHSVtoRGB() is a built-in function that Q provides.
                
                // This varies the scale by saturation instead of hue:
                var color = convertHSVtoRGB(32, scale, 1);

                // Try and experiment using some different color schemes.
                
             // In this scheme,
             //  the lowest color has a hue of 240 (blue).
                //  the highest color has hue of 0 (red).
                // The beauty of the Hue, Saturation, Value (or Brightness) color space
                // means that changing the value of Hue proportionally makes the color
                // look 'hotter'.
                //var color = convertHSVtoRGB(240 * (1 - scale), 1, 1);
                
                // Set the color for this cell.
                cell_colors[row][column] = color;
            }
        }
        
 // Set the array of cell colors we just modified.
 table.cellColors = cell_colors;

 // Cells that belong to our brand of interest, Coke,
// will have green/brown text instead of the default blue/red.
table.requireNumericTable();
var brand = 'Coke';
var positive_color = 'limegreen';
var negative_color = 'brown'
var font_colors = table.cellFontColors;
var significant = table.cellSignificance;
var zstatistic = table.get('z-Statistic');
table.rowIndices(true).forEach(function (row) {
    table.columnIndices(true).forEach(function (column) {
        if (significant[row][column]
            && (table.rowLabels[row].indexOf(brand) >= 0
                || table.columnLabels[column].indexOf(brand) >= 0)) {
            if (zstatistic[row][column] > 0)
                font_colors[row][column] = positive_color;
            else
                font_colors[row][column] = negative_color;
        }
    });
});
table.cellFontColors = font_colors;

 // Mark any column with significant cells with an asterisk (*).
table.requireNumericTable();
var symbol = '*';
var column_labels = table.columnLabels;
var significant = table.cellSignificance;
table.columnIndices(true).forEach(function (column) {
    var any_significant = table.rowIndices(true).some(function (row) {
        return significant[row][column];
    });
    if (any_significant)
        column_labels[column] = column_labels[column] + symbol;
});
table.columnLabels = column_labels;

 // Display an exclamation point next to the first statistic in each cell, if it is over 80.

// Get the values for the first statistic shown on the table.
var values = table.get(table.statistics[0]);

// Get the default text in each cell in the table.
var cell_texts = table.cellText;

// Loop through each cell...
for (var row = 0; row < table.numberRows; row++)
    for (var column = 0; column < table.numberColumns; column++) {
        var value = values[row][column];
        if (value > 80) {
            // Put an exclamation point next to the first statistic.
            cell_texts[row][column] = ['!'];
        }
    }
    
// Now store the new cell texts.
table.cellText = cell_texts;

 // Show column comparisons to the right of the first statistic's values.

var first_stat = table.statistics[0];

// If the first value in each cell is the column comparisons already
// then nothing to do here.
if (first_stat != 'Column Comparisons') {
// Try to get the column comparisons.
var column_comparisons = table.get('Column Comparisons');

// Get the default text in each cell in the table.
var cell_texts = table.cellText;

// Loop through each cell...
for (var row = 0; row < table.numberRows; row++)
    for (var column = 0; column < table.numberColumns; column++) {
       // Set the cell text to be the column comparison value for this cell,
       // with a space before it.
       var comparison_text = column_comparisons[row][column];
       // Removing spaces.
       var text_without_spaces = comparison_text.replace(/ /g,"");
       // Inserting into cell.
       cell_texts[row][column] = [' ' + text_without_spaces];
    }
    
    // Now store the new cell texts.
    table.cellText = cell_texts;
}

table.columnIndices(false).forEach(function (column) {
    ... do something for each index ...
});

 // Add three asterisks next to the Coke category,
// to bring it to the attention of the client.

// Get the existing column labels.
var column_labels = table.columnLabels;

// For each column...
for (var column = 0; column < table.numberColumns; column++)
    // If the label is "Coca Cola"...
    if (column_labels[column] == 'Coca Cola')
        // ... add (+=) three asterisks
        column_labels[column] += '***';
        
// Use our modified labels as the new column labels.
table.columnLabels = column_labels;

 // Under the standard column labels, add:
// * Column name (A, B, C...)
// * Column n

// Get the column names and column n values
var column_names = table.get('Column Names');
var column_ns = table.get('Column n');

// Get the standard column labels.
var column_labels = table.columnLabels;

// For each column...
for (var column = 0; column < table.numberColumns; column++) {
    // Adjust the label to include the column name and column n, on new lines.
    // '\r\n' is a special carriage-return code.
    column_labels[column] = column_labels[column] + '\r\n' +
        column_names[0][column] + '\r\n' +
        'n = ' + column_ns[0][column];
}

// Set the adjusted column labels.
table.columnLabels = column_labels;

log(table.decimalPlaces['Average']);

table.deleteColumn(table.columnIndex('NET'));

table.deleteRow(table.rowIndex('NET'));

data_file.getQuestionByName('Q2').equals(data_file.questions()[0])

 // Inserts a footer entry which shows the smallest cell size in the table.

// Get the sizes of each cell.
var sizes = table.get('n');

// Keep track of the smallest size.
var smallest_size;

// For each cell...
for (var row = 0; row < table.numberRows; row++)
    for (var col = 0; col < table.numberColumns; col++) {
        if (row == 0 && col == 0)
            // If this is the first cell, store its size.
            smallest_size = sizes[row][col];
        else
            // Otherwise, use the smaller of the existing size or this new one.
            smallest_size = Math.min(smallest_size, sizes[row][col]);
    }
    
// Now we have the smallest size.  Create and store
// the list of extra footers, with our new entry:
table.extraFooters = ['Smallest cell: ' + smallest_size + ' respondents.'];

if(table.forPlot)
    alert("This is for a plot.");

 // Whenever a Column N is less than 30, add an asterisk next to the column name,
// and add a footnote explaining the asterisk.

// Get the Column N statistics.
var column_ns = table.get('Column n');

// Get the column labels.
var column_labels = table.columnLabels;

// Make a list of extra footnotes.
var footnotes = table.extraFooters;

// For each column...
for (var column = 0; column < table.numberColumns; column++) {
    // Get the column n statistic (from the cell in the first row).
    var column_n = column_ns[0][column];
    
    if (column_n < 30) {
        // Add an extra footnote.
        footnotes.push('* column "' + column_labels[column] + '" has less than 30 respondents.');
        
        // Put a marker on this column's label.
        column_labels[column] += '*';
    }
}

// Store the adjusted column labels and footnotes.
table.columnLabels = column_labels;
table.extraFooters = footnotes;

alert(table.getTranslation('Column n'));

table.hypothesisTestingEnabled = false; // alpha button disabled

 // Insert an average of the existing average statistics above this row.

// Insert a new row to store the numbers.
table.insertRowAfter(table.numberRows - 1, 'Column Average');

// Get the average values for each cell.
var averages = table.get('Average');

// Get the not duplicate markers for each cell.  This
// indicates whether the cell has been copied from
// another cell, such as when NETs are created.
var not_duplicates = table.get('Not Duplicate');

// For each column...
for (var column = 0; column < table.numberColumns; column++) {
    // Keep track of the sum of averages, and the number of
    // non-duplicate rows so far.
    var sum = 0;
    var unique_rows = 0;
    
    // For each row...
    for (var row = 0; row < table.numberRows; row++)
        // If this cell is not a duplicate...
        if (not_duplicates[row][column]) {
            // Add its average value to this column's sum.
            sum += averages[row][column];
            // And increase the count of non-duplicate rows.
            unique_rows++;
        }
        
    // We now have a sum of all the averages in this column.
    // Compute the average.
    var average = sum / unique_rows;
    
    // Store the average in the new 'Column Average' row
    // we added above.
    averages[table.numberRows - 1][column] = average;
}

// Use our new average values.
table.set('Average', averages);

 // Add two numbers together in a new row.

// Find out where the two rows are.
var row_one = table.rowIndex('Coca Cola');
var row_two = table.rowIndex('Diet Coke');

// Create a new row to store the new number.
table.insertRowAfter(row_two, 'Combined Coke');
var new_row = row_two + 1;

// Get the first statistic on the table.
var first_statistic = table.statistics[0];

// Get the values of the first statistic.
var statistic_values = table.get(first_statistic);

// Add the two numbers together.
var sum = statistic_values[row_one][0] + statistic_values[row_two][0];

// Store the sum of the two numbers.
statistic_values[new_row][0] = sum;

// Store the new values for the first statistic.
table.set(first_statistic, statistic_values);

 // Move 'Coca Cola' to be after 'Pepsi'.
table.moveColumnAfter(table.columnIndex('Coca Cola'), table.columnIndex('Pepsi'));

 // Move 'Coca Cola' to be after 'Pepsi'.
table.moveRowAfter(table.rowIndex('Coca Cola'), table.rowIndex('Pepsi'));

table.requireOriginalCellStatistics(null);

table.requireOriginalCellStatistics('Average');

table.requireOriginalRowsColumns();

table.columnIndices(false).forEach(function (column) {
    ... do something for each index ...
});

 // Add three asterisks next to the Coke category,
// to bring it to the attention of the client.

// Get the existing row labels.
var row_labels = table.rowLabels;

// For each row...
for (var row = 0; row < table.numberRows; row++)
    // If the label is "Coca Cola"...
    if (row_labels[row] == 'Coca Cola')
        // ... add (+=) three asterisks
        row_labels[row] += '***';

// Use our modified labels as the new row labels.
table.rowLabels = row_labels;

 // Add a new Average row to every span, that averages
// the statistics of the other rows in that span.

// Get the list of spans.
var spans = table.rowSpans;

// Get the list of statistics on the table.
var statistics = table.statistics;

// Working backwards through the list of spans...
for (var i = spans.length - 1; i >= 0; i--) {
    // Get the current span.
    var span = spans[i];
    
    // Get the rows in this span.
    var rows = span.indices;
    
    // What is the last row in this span?
    var last_row = rows[rows.length - 1];
    
    // Add a new Average row.
    table.insertRowAfter(last_row, 'Average');
    
    // Remember the index of the new Average row.
    var average_row = last_row + 1;
    
    // For each other row in this span, sum its statistics.
    
    // For each column...
    for (var column = 0; column < table.numberColumns; column++) {
        // For each statistic in the table...
        for (var stat = 0; stat < statistics.length; stat++) {
            var values = table.get(statistics[stat]);
            var sum = 0;

            for (var j = 0; j < rows.length; j++) {
                var row = rows[j];
                sum += values[row][column];
            }
        
            // Store the average in the new Average row.
            values[average_row][column] = sum / rows.length;
            
            // Store the values of the Average row into the table.
            table.set(statistics[stat], values);
        }
    }
}

 // Show a "-" instead of "NaN" for missing values.
table.showMissingAs('-');

table.showPercentSign = true;

 // Sort the rows by the right-most column.
// Uses the first statistic in each cell as the comparison value.

// Get the values of the first statistic.
var first_statistic = table.statistics[0];
var values = table.get(first_statistic);

// Create an array of the original row numbers, which we will sort.
var row_indices = [];
for (var row = 0; row < table.numberRows; row++)
    row_indices.push(row);
    
var last_column = table.numberColumns - 1;
    
// Now sort the array of row numbers by the statistical values.
// This 'function' is run many times - to compare each row against another.
row_indices.sort(function (row_x, row_y) {

    // Get the values for the two rows we are comparing.
    var value_x = values[row_x][last_column];
    var value_y = values[row_y][last_column];
    
    // Sort by the difference in the values.
    // This sorts in ascending order (smallest value at the top).
    // If you wanted descending order, you could change this to:
    //  value_y - value_x
    return value_x - value_y;
});

// NETs, SUMs, Others and Don't Knows are always at the bottom of the table.
var always_bottom_labels = ['Other', "Don't know", 'NET', 'SUM'];
// For each label...
for (var i = 0; i < always_bottom_labels.length; i++) {
    var label = always_bottom_labels[i];
    
    // Try to get its row position.
    var row = table.rowIndex(label);
    if (row != -1) {
        // If it exists (has a row position)...
        
        // Find its position in the sorted row numbers.
        var sorted_row = row_indices.indexOf(row);
        
        // Remove it from the sorted row numbers.
        row_indices.splice(sorted_row, 1);
        
        // Add it to the sorted row numbers, to the end.
        row_indices.push(row);
    }
}

// Finally, our row numbers are now sorted in the order we want.
// Instruct the table to sort the rows according to the new order.
table.sortRows(row_indices);

 // Span the Coke brands.
 table.spanColumns([table.columnIndex('Coca Cola'),
                    table.columnIndex('Diet Coke'),
                    table.columnIndex('Coke Zero')],
                   'Coke Brands');

 // Span the Pepsi brands.
 table.spanColumns([table.columnIndex('Pepsi Light'),
                    table.columnIndex('Pepsi Max'),
                    table.columnIndex('Pepsi')],
                   'Pepsi Brands');

 // Span the Coke brands.
 table.spanRows([table.rowIndex('Coca Cola'),
                 table.rowIndex('Diet Coke'),
                 table.rowIndex('Coke Zero')],
                'Coke Brands');

 // Span the Pepsi brands.
 table.spanRows([table.rowIndex('Pepsi Light'),
                 table.rowIndex('Pepsi Max'),
                 table.rowIndex('Pepsi')],
                'Pepsi Brands');

alert('The overall significance level is:' + table.statisticalAssumptions.overallSignificanceLevel);

 // Sort the statistics that are already shown on the table,
 // and then add Average at the end.
 
 // Get the existing statistics on the table (selected by the context menu).
 var stats = table.statistics;
 
 // Sort them alphabetically.
 stats.sort();
 
 // Add Average.
 stats.push('Average');
 
 // Use our new list as the statistics.
 table.statistics = stats;

 // Do not show the output if any of the questions were
// answered by less than 10 respondents, because it means the filter that
// was applied by the user is too restrictive.

// Get the 'Base n' statistic values for each cell.
var base_ns = table.get('Base n');

// The message to show instead of the real table.
var message = 'The filters you have applied contain too few people.\n' +
              'Change the filters to see this table again.';

// If any of the 'Base n' values are less than 10, suppress the
// output with a message explaining why.
for (var row = 0; row < table.numberRows; row++)
    for (var column = 0; column < table.numberColumns; column++)
        if (base_ns[row][column] < 10)
            table.suppressOutput(message);