Make a table for the given number of steps.

For step numbers divisible by 4, an optimized implementation will be used.

@param steps Number of steps
@return Table
494302
public static SinCosTable make(int steps) {
    if ((steps & 0x3) == 0) {
      return new QuarterTable(steps);
    }
    if ((steps & 0x1) == 0) {
      return new HalfTable(steps);
    }
    return new FullTable(steps);
  }
938152
public CreateTableRequest getTableSchema() {
        return new CreateTableRequest()
                .withTableName(tableName)
                .withProvisionedThroughput(new ProvisionedThroughput(client.readCapacity(tableName),
                        client.writeCapacity(tableName)));
    }
1195337
public static AbstractExpression createIndexExpressionForTable(Table table, Map<Integer, Integer> ranges)
    {
        HashRangeExpression predicate = new HashRangeExpression();
        predicate.setRanges(ranges);
        predicate.setHashColumnIndex(table.getPartitioncolumn().getIndex());

        return predicate;
    }
342461
protected Table generateTable(int tableIndex) {

        switch (tableIndex) {

            case SYSTEM_UDTS :
                return SYSTEM_UDTS();

            case SYSTEM_VERSIONCOLUMNS :
                return SYSTEM_VERSIONCOLUMNS();

            // HSQLDB-specific
            case SYSTEM_CACHEINFO :
                return SYSTEM_CACHEINFO();

            case SYSTEM_SESSIONINFO :
                return SYSTEM_SESSIONINFO();

            case SYSTEM_PROPERTIES :
                return SYSTEM_PROPERTIES();

            case SYSTEM_SESSIONS :
                return SYSTEM_SESSIONS();

            case SYSTEM_TEXTTABLES :
                return SYSTEM_TEXTTABLES();

            // SQL views
            case ADMINISTRABLE_ROLE_AUTHORIZATIONS :
                return ADMINISTRABLE_ROLE_AUTHORIZATIONS();

            case APPLICABLE_ROLES :
                return APPLICABLE_ROLES();

            case ASSERTIONS :
                return ASSERTIONS();

            case AUTHORIZATIONS :
                return AUTHORIZATIONS();

            case CHARACTER_SETS :
                return CHARACTER_SETS();

            case CHECK_CONSTRAINT_ROUTINE_USAGE :
                return CHECK_CONSTRAINT_ROUTINE_USAGE();

            case CHECK_CONSTRAINTS :
                return CHECK_CONSTRAINTS();

            case COLLATIONS :
                return COLLATIONS();

            case COLUMN_COLUMN_USAGE :
                return COLUMN_COLUMN_USAGE();

            case COLUMN_DOMAIN_USAGE :
                return COLUMN_DOMAIN_USAGE();

            case COLUMN_UDT_USAGE :
                return COLUMN_UDT_USAGE();

            case CONSTRAINT_COLUMN_USAGE :
                return CONSTRAINT_COLUMN_USAGE();

            case CONSTRAINT_TABLE_USAGE :
                return CONSTRAINT_TABLE_USAGE();

            case COLUMNS :
                return COLUMNS();

            case DATA_TYPE_PRIVILEGES :
                return DATA_TYPE_PRIVILEGES();

            case DOMAIN_CONSTRAINTS :
                return DOMAIN_CONSTRAINTS();

            case DOMAINS :
                return DOMAINS();

            case ENABLED_ROLES :
                return ENABLED_ROLES();

            case JAR_JAR_USAGE :
                return JAR_JAR_USAGE();

            case JARS :
                return JARS();

            case KEY_COLUMN_USAGE :
                return KEY_COLUMN_USAGE();

            case METHOD_SPECIFICATIONS :
                return METHOD_SPECIFICATIONS();

            case MODULE_COLUMN_USAGE :
                return MODULE_COLUMN_USAGE();

            case MODULE_PRIVILEGES :
                return MODULE_PRIVILEGES();

            case MODULE_TABLE_USAGE :
                return MODULE_TABLE_USAGE();

            case MODULES :
                return MODULES();

            case PARAMETERS :
                return PARAMETERS();

            case REFERENTIAL_CONSTRAINTS :
                return REFERENTIAL_CONSTRAINTS();

            case ROLE_AUTHORIZATION_DESCRIPTORS :
                return ROLE_AUTHORIZATION_DESCRIPTORS();

            case ROLE_COLUMN_GRANTS :
                return ROLE_COLUMN_GRANTS();

            case ROLE_ROUTINE_GRANTS :
                return ROLE_ROUTINE_GRANTS();

            case ROLE_TABLE_GRANTS :
                return ROLE_TABLE_GRANTS();

            case ROLE_USAGE_GRANTS :
                return ROLE_USAGE_GRANTS();

            case ROLE_UDT_GRANTS :
                return ROLE_UDT_GRANTS();

            case ROUTINE_COLUMN_USAGE :
                return ROUTINE_COLUMN_USAGE();

            case ROUTINE_JAR_USAGE :
                return ROUTINE_JAR_USAGE();

            case ROUTINE_PRIVILEGES :
                return ROUTINE_PRIVILEGES();

            case ROUTINE_ROUTINE_USAGE :
                return ROUTINE_ROUTINE_USAGE();

            case ROUTINE_SEQUENCE_USAGE :
                return ROUTINE_SEQUENCE_USAGE();

            case ROUTINE_TABLE_USAGE :
                return ROUTINE_TABLE_USAGE();

            case ROUTINES :
                return ROUTINES();

            case SCHEMATA :
                return SCHEMATA();

            case SEQUENCES :
                return SEQUENCES();

            case SQL_FEATURES :
                return SQL_FEATURES();

            case SQL_IMPLEMENTATION_INFO :
                return SQL_IMPLEMENTATION_INFO();

            case SQL_PACKAGES :
                return SQL_PACKAGES();

            case SQL_PARTS :
                return SQL_PARTS();

            case SQL_SIZING :
                return SQL_SIZING();

            case SQL_SIZING_PROFILES :
                return SQL_SIZING_PROFILES();

            case TABLE_CONSTRAINTS :
                return TABLE_CONSTRAINTS();

            case TABLES :
                return TABLES();

            case TRANSLATIONS :
                return TRANSLATIONS();

            case TRIGGERED_UPDATE_COLUMNS :
                return TRIGGERED_UPDATE_COLUMNS();

            case TRIGGER_COLUMN_USAGE :
                return TRIGGER_COLUMN_USAGE();

            case TRIGGER_ROUTINE_USAGE :
                return TRIGGER_ROUTINE_USAGE();

            case TRIGGER_SEQUENCE_USAGE :
                return TRIGGER_SEQUENCE_USAGE();

            case TRIGGER_TABLE_USAGE :
                return TRIGGER_TABLE_USAGE();

            case TRIGGERS :
                return TRIGGERS();

            case USAGE_PRIVILEGES :
                return USAGE_PRIVILEGES();

            case USER_DEFINED_TYPES :
                return USER_DEFINED_TYPES();

            case VIEW_COLUMN_USAGE :
                return VIEW_COLUMN_USAGE();

            case VIEW_ROUTINE_USAGE :
                return VIEW_ROUTINE_USAGE();

            case VIEW_TABLE_USAGE :
                return VIEW_TABLE_USAGE();

            case VIEWS :
                return VIEWS();

            default :
                return super.generateTable(tableIndex);
        }
    }
826239
public static Integer[] sequence(final Integer from, final Integer to, final Integer step) {
        
        Validate.notNull(from, "Value to start the sequence from cannot be null");
        Validate.notNull(to, "Value to generate the sequence up to cannot be null");
        Validate.notNull(step, "Step to generate the sequence cannot be null");
        
        final int iFrom = from.intValue();
        final int iTo = to.intValue();
        final int iStep = step.intValue();

        if (iFrom == iTo) {
            return new Integer[] {Integer.valueOf(iFrom)};
        }

        if (iStep == 0) {
            // with iStep == 0, this would only be valid if iFrom == iTo, which it isn't - the rest are impossible
            throw new IllegalArgumentException("Cannot create sequence from " + iFrom + " to " + iTo + " with step " + iStep);
        }

        final List<Integer> values = new ArrayList<Integer>(10);
        if (iFrom < iTo && iStep > 0) {
            int i = iFrom;
            while (i <= iTo) {
                values.add(Integer.valueOf(i));
                i += iStep;
            }
        } else if (iFrom > iTo && iStep < 0){
            // iFrom > iTo
            int i = iFrom;
            while (i >= iTo) {
                values.add(Integer.valueOf(i));
                i += iStep;
            }
        }

        return values.toArray(new Integer[values.size()]);
        
    }
526652
private static int[] make_crc_table() {
        int[] crc_table = new int[256];
        for (int n = 0; n < 256; n++) {
            int c = n;
            for (int k = 8; --k >= 0; ) {
                if ((c & 1) != 0)
                    c = 0xedb88320 ^ (c >>> 1);
                else
                    c = c >>> 1;
            }
            crc_table[n] = c;
        }
        return crc_table;
    }
520278
function(step){
		var range = [],
			v = this.min;
		while(v < this.max){
			range.push(v);
			v += step;
		}
		return range;
	}
290155
private static char[] buildTable() {
    char[] table = new char[26];
    for (int ix = 0; ix < table.length; ix++)
      table[ix] = '0';
    table['B' - 'A'] = '1';
    table['P' - 'A'] = '1';
    table['F' - 'A'] = '1';
    table['V' - 'A'] = '1';
    table['C' - 'A'] = '2';
    table['S' - 'A'] = '2';
    table['K' - 'A'] = '2';
    table['G' - 'A'] = '2';
    table['J' - 'A'] = '2';
    table['Q' - 'A'] = '2';
    table['X' - 'A'] = '2';
    table['Z' - 'A'] = '2';
    table['D' - 'A'] = '3';
    table['T' - 'A'] = '3';
    table['L' - 'A'] = '4';
    table['M' - 'A'] = '5';
    table['N' - 'A'] = '5';
    table['R' - 'A'] = '6';
    return table;
  }
196528
private WDataTable createTable() {
		WDataTable tbl = new WDataTable();
		tbl.addColumn(new WTableColumn("First name", new WTextField()));
		tbl.addColumn(new WTableColumn("Last name", new WTextField()));
		tbl.addColumn(new WTableColumn("DOB", new WDateField()));
		return tbl;
	}
134390
private static Set<String> getIndexedColumnSetForTable(Table table) {
        HashSet<String> columns = new HashSet<>();

        for (Index index : table.getIndexes()) {
            for (ColumnRef colRef : index.getColumns()) {
                columns.add(colRef.getColumn().getTypeName());
            }
        }

        return columns;
    }
173401
public Table copy() {
        Table copy = new Table(name);
        for (Column<?> column : columnList) {
            copy.addColumns(column.emptyCopy(rowCount()));
        }

        int[] rows = new int[rowCount()];
        for (int i = 0; i < rowCount(); i++) {
            rows[i] = i;
        }
        Rows.copyRowsToTable(rows, this, copy);
        return copy;
    }
798347
function createTable (spec) {
  assert.equal(typeof spec.paths, 'object', 'paths should be object')

  const tableHead = u('tableHeader', [
    u('tableCell', [ u('text', 'Path') ]),
    u('tableCell', [ u('text', 'Method') ]),
    u('tableCell', [ u('text', 'Summary') ])
  ])

  // convert swagger to table rows
  const tableRows = Object.keys(spec.paths).reduce(function (arr, route) {
    Object.keys(spec.paths[route]).forEach(function (method) {
      const summary = spec.paths[route][method].summary || '[ not available ]'
      arr.push(u('tableRow', [
        u('tableCell', [ u('text', route) ]),
        u('tableCell', [ u('text', method.toUpperCase()) ]),
        u('tableCell', [ u('text', summary) ])
      ]))
    })
    return arr
  }, [])

  return u('table', [tableHead].concat(tableRows))
}
1163080
private TableModel createTableModel(Object object, Set<String> excludedMethods)
   {
      List<Method> methods = new ArrayList<Method>();
      for (Method method : object.getClass().getMethods())
      {
         if ((method.getParameterTypes().length == 0) || (method.getParameterTypes().length == 1 && method.getParameterTypes()[0] == int.class))
         {
            String name = method.getName();
            if (!excludedMethods.contains(name) && (name.startsWith("get") || name.startsWith("is")))
            {
               methods.add(method);
            }
         }
      }

      Map<String, String> map = new TreeMap<String, String>();
      for (Method method : methods)
      {
         if (method.getParameterTypes().length == 0)
         {
            getSingleValue(method, object, map);
         }
         else
         {
            getMultipleValues(method, object, map);
         }
      }

      String[] headings = new String[]
      {
         "Property",
         "Value"
      };

      String[][] data = new String[map.size()][2];
      int rowIndex = 0;
      for (Entry<String, String> entry : map.entrySet())
      {
         data[rowIndex][0] = entry.getKey();
         data[rowIndex][1] = entry.getValue();
         ++rowIndex;
      }

      TableModel tableModel = new DefaultTableModel(data, headings)
      {
         @Override public boolean isCellEditable(int r, int c)
         {
            return false;
         }
      };

      return tableModel;
   }
716618
public VisTable createTable () {
		VisTable table = new VisTable(true);

		table.left();

		boolean spacingValid = false;
		for (int i = 0; i < order.length(); i++) {
			char ch = order.charAt(i);

			if (ignoreSpacing == false && ch == ' ' && spacingValid) {
				table.add().width(sizes.buttonBarSpacing);
				spacingValid = false;
			}

			Button button = buttons.get(ch);

			if (button != null) {
				table.add(button);
				spacingValid = true;
			}
		}

		return table;
	}
480040
public Table getTable(){
        final Table table = new Table(getHeaders());

        // Create row(s) per dependency
        for(final Dependency dependency: dependencies){
            final List<String> licenseIds = dependency.getTarget().getLicenses();

            // A dependency can have many rows if it has many licenses
            if(licenseIds.isEmpty()){
                table.addRow(getDependencyCells(dependency, DataModelFactory.createLicense("","","","","")));
            }
            else{
                for(final String licenseId: dependency.getTarget().getLicenses()){
                    final License license = getLicense(licenseId);
                    table.addRow(getDependencyCells(dependency, license));
                }
            }
        }

        return table;
    }
846519
public ListStepsRequest withStepStates(StepState... stepStates) {
        com.amazonaws.internal.SdkInternalList<String> stepStatesCopy = new com.amazonaws.internal.SdkInternalList<String>(stepStates.length);
        for (StepState value : stepStates) {
            stepStatesCopy.add(value.toString());
        }
        if (getStepStates() == null) {
            setStepStates(stepStatesCopy);
        } else {
            getStepStates().addAll(stepStatesCopy);
        }
        return this;
    }
203177
public Rule TableColumn(Var<TableNode> tableNode, Var<Boolean> pipeSeen) {
        Var<TableColumnNode> node = new Var<TableColumnNode>(new TableColumnNode());
        return Sequence(
                NodeSequence(
                        push(node.get()),
                        Sp(),
                        Optional(':', node.get().markLeftAligned()),
                        Sp(), OneOrMore('-'), Sp(),
                        Optional(':', node.get().markRightAligned()),
                        Sp(),
                        Optional('|', pipeSeen.set(Boolean.TRUE))
                ),
                tableNode.get().addColumn((TableColumnNode) pop())
        );
    }