For backward compatibility only
558335
private Object readResolve() throws ObjectStreamException {
        // The old index field used to uniquely identify the time unit.
        switch (index) {
        case 6:
            return SECOND;
        case 5:
            return MINUTE;
        case 4:
            return HOUR;
        case 3:
            return DAY;
        case 2:
            return WEEK;
        case 1:
            return MONTH;
        case 0:
            return YEAR;
        default:
            throw new InvalidObjectException("Bad index: " + index);
        }
    }
707983
@Override
    public void backward() {
        MVecArray<VarTensor> xs = modIn.getOutput();
        MVecArray<VarTensor> xsAdj = modIn.getOutputAdj();
        for (int a=0; a<xsAdj.dim(); a++) {
            VarTensor xAdj = xsAdj.get(a);
            // Compute the product of all the input factors except for a.
            // We compute this cavity by brute force, rather than dividing out from the joint.
            VarTensor prod = new VarTensor(yAdj);
            for (int b=0; b<xsAdj.dim(); b++) {
                if (a == b) { continue; }
                prod.prod(xs.get(b));
            }
            xAdj.add(prod.getMarginal(xAdj.getVars(), false));
        }
    }
917562
@SuppressWarnings({"unchecked", "deprecation"})
	private static <T> TypeSerializerSnapshot<T> configureForBackwardsCompatibility(
			TypeSerializerSnapshot<?> snapshot,
			TypeSerializer<?> serializer) {

		TypeSerializerSnapshot<T> typedSnapshot = (TypeSerializerSnapshot<T>) snapshot;
		TypeSerializer<T> typedSerializer = (TypeSerializer<T>) serializer;

		if (snapshot instanceof TypeSerializerConfigSnapshot) {
			((TypeSerializerConfigSnapshot<T>) typedSnapshot).setPriorSerializer(typedSerializer);
		}

		return typedSnapshot;
	}
121796
private int compareToVersionNumber(VersionIdentifier otherVersion) {

    // Example version: 1.2.3.4
    // Direct successors: 1.2.3.5 / 1.2.4[.0] / 1.3.[.0[.0]] / 2.[.0[.0[.0]]]
    // Direct predecessors: 1.2.3.3[.*]
    boolean equivalent = true;
    int result = 0;
    int maxSegmentCount = StrictMath.max(getVersionSegmentCount(), otherVersion.getVersionSegmentCount());
    for (int i = 0; i < maxSegmentCount; i++) {
      int segment = getVersionSegment(i);
      int otherSegment = otherVersion.getVersionSegment(i);
      if (segment != otherSegment) {
        int delta = segment - otherSegment;
        if (equivalent) {
          result = delta;
        } else {
          if (result == COMPARE_TO_STRICT_SUCCESSOR) {
            if (segment != 0) {
              result++;
              break;
            }
          } else if (result == COMPARE_TO_STRICT_PREDECESSOR) {
            if (otherSegment != 0) {
              result--;
              break;
            }
          }
        }
      }
    }
    return result;
  }
615609
def backwards(self, orm):
        ""
        for c in orm["contenttypes.contenttype"].objects.all():
            if c.app_label == "dublincore":
                c.app_label = "DublinCore"
                c.save()
536082
def backward(self, speed=1):
        
        if isinstance(self.enable_device, DigitalOutputDevice):
            if speed not in (0, 1):
                raise ValueError(
                    'backward speed must be 0 or 1 with non-PWM Motors')
        self.enable_device.off()
        self.phase_device.on()
        self.enable_device.value = speed
405656
@Override
    public void backward() {
        // TODO: This is less numerically stable than the O(n^2) method of
        // multiplying \prod_{j=1}^{i-1} x_j \prod_{j+1}^n x_j  
        Tensor x = modIn.getOutput();
        Tensor xAdj = modIn.getOutputAdj();
        Tensor tmp = new Tensor(xAdj); // copy
        tmp.fill(yAdj.getValue(0));
        tmp.multiply(y.getValue(0));
        tmp.elemDivide(x);
        xAdj.elemAdd(tmp);
    }
857561
public static boolean isNewerUnsupportedVersion(String version) {
		if ((version == null) || "".equals(version)) {
			return true;
		}
		String engineVersion = ReleaseInfoAdapter.getVersionNumber();
		String[] ev = engineVersion.split("\\.");
		String[] rv = version.split("\\.");
		return ((Integer.parseInt(ev[0]) < Integer.parseInt(rv[0])) || ((Integer.parseInt(ev[0]) == Integer.parseInt(rv[0])) && (Integer
				.parseInt(ev[1]) < Integer.parseInt(rv[1]))));
	}
43257
function () {
        /* BACKWARD-COMPATIBILITY-BEGIN (GitHub #1397) */
        /**
         * <b>Deprecated, use aria.core.Browser.ua instead.</b>
         *
         * <p>
         * The user agent string.
         * </p>
         *
         * @type String
         * @deprecated use aria.core.Browser.ua instead
         */
        this.ua = null;
         */

        /**
         * Previous orientation value to check if event should be raised (value changed or not).
         * @type Boolean
         * @private
         */
        this._previousIsPortrait = this.isPortrait(true);

        /* BACKWARD-COMPATIBILITY-BEGIN (GitHub #1397) */
        this._deprecatedProperties = []; // for init to process well
         */

        /* BACKWARD-COMPATIBILITY-BEGIN (GitHub #1397) */
        var properties = [
            {
                name: "ua",
                alternative: "aria.core.Browser.ua"
            },

            {
                name: "isMobile",
                type: "method",
                underlying: "isPhone"
            },
            {
                name: "isPhoneGap",
                type: "method",
                underlying: {
                    name: "isPhoneGap",
                    container: ariaCoreBrowser,
                    containerName: "aria.core.Browser"
                }
            },
            {
                name: "is2DTransformCapable",
                type: "method",
                underlying: {
                    name: "is2DTransformCapable",
                    container: ariaCoreBrowser,
                    containerName: "aria.core.Browser"
                }
            },
            {
                name: "is3DTransformCapable",
                type: "method",
                underlying: {
                    name: "is3DTransformCapable",
                    container: ariaCoreBrowser,
                    containerName: "aria.core.Browser"
                }
            }
        ];

        var deprecatedProperties = [];
        var isString = ariaUtilsType.isString;
        ariaUtilsArray.forEach(properties, function(property) {
            // ------------------------------------------------ property factory

            if (ariaUtilsType.isString(property)) {
                property = {name: property};
            }

            // ------------------------------------------------------------ name

            var name = property.name;

            // ------------------------------------------------------------ type

            var type = property.type;

            if (type == null) {
                type = "attribute";
            }

            property.type = type;

            // ----------------------------------------------- underlying method

            var possibleAlternative;

            if (type == "method") {
                var underlying = property.underlying;

                if (isString(underlying)) {
                    underlying = {name: underlying};
                }

                var underlyingName = underlying.name;

                var underlyingContainer = underlying.container;
                if (underlyingContainer == null) {
                    underlyingContainer = this;
                }
                underlying.container = underlyingContainer;

                var underlyingContainerName = underlying.containerName;

                // -------------------------------------------------------------

                possibleAlternative = "";
                if (underlyingContainerName != null) {
                    possibleAlternative += underlyingContainerName + ".";
                }
                possibleAlternative += underlyingName;

                underlying = function() {
                    return underlyingContainer[underlyingName].apply(underlyingContainer, arguments);
                };

                property.underlying = underlying;
            }

            // ----------------------------------------------------- alternative

            var alternative = property.alternative;

            if (alternative == null && possibleAlternative != null) {
                alternative = possibleAlternative;
            }

            property.alternative = alternative;

            // --------------------------------------------------- extrapolation

            var loggingMessage;
            var loggingMessageArguments = [name];

            if (alternative != null) {
                loggingMessage = type == "attribute" ? "DEPRECATED_REPLACED_PROPERTY" : "DEPRECATED_REPLACED_METHOD";
                loggingMessageArguments.push(alternative);
            } else {
                loggingMessage = type == "attribute" ? "DEPRECATED_REMOVED_PROPERTY" : "DEPRECATED_REMOVED_METHOD";
            }

            property.loggingMessage = this[loggingMessage];
            property.loggingMessageArguments = loggingMessageArguments;

            // ---------------------------------------------------------- result

            deprecatedProperties.push(property);
        }, this);

        this._deprecatedProperties = deprecatedProperties;
        this.__deprecateProperties();
         */

        this.init();
    }
931695
def _apply_backwards_compatibility(df):
    
    df.row_count = types.MethodType(lambda self: len(self.index), df)
    df.col_count = types.MethodType(lambda self: len(self.columns), df)
    df.dataframe = df
625553
function RarReadTables(bstream) {
    var BitLength = new Array(RarUtils.CONST.rBC),
        Table = new Array(RarUtils.CONST.rHUFF_TABLE_SIZE);

    // before we start anything we need to get byte-aligned
    bstream.readBits((8 - bstream.bitPtr) & 0x7);

    if (bstream.readBits(1)) {
        console.info("Error!  PPM not implemented yet");
        return;
    }

    if (!bstream.readBits(1)) { //discard old table
        for (var i = UnpOldTable.length; i--;) UnpOldTable[i] = 0;
    }

    // read in bit lengths
    for (var I = 0; I < RarUtils.CONST.rBC; ++I) {

        var Length = bstream.readBits(4);
        if (Length == 15) {
            var ZeroCount = bstream.readBits(4);
            if (ZeroCount == 0) {
                BitLength[I] = 15;
            } else {
                ZeroCount += 2;
                while (ZeroCount-- > 0 && I < RarUtils.CONST.rBC)
                    BitLength[I++] = 0;
                --I;
            }
        } else {
            BitLength[I] = Length;
        }
    }

    // now all 20 bit lengths are obtained, we construct the Huffman Table:

    RarUtils.RarMakeDecodeTables(BitLength, 0, RarUtils.CONST.BD, RarUtils.CONST.rBC);

    var TableSize = RarUtils.CONST.rHUFF_TABLE_SIZE;
    //console.log(DecodeLen, DecodePos, DecodeNum);
    for (var i = 0; i < TableSize;) {
        var num = RarUtils.RarDecodeNumber(bstream, RarUtils.CONST.BD);
        if (num < 16) {
            Table[i] = (num + UnpOldTable[i]) & 0xf;
            i++;
        } else if (num < 18) {
            var N = (num == 16) ? (bstream.readBits(3) + 3) : (bstream.readBits(7) + 11);

            while (N-- > 0 && i < TableSize) {
                Table[i] = Table[i - 1];
                i++;
            }
        } else {
            var N = (num == 18) ? (bstream.readBits(3) + 3) : (bstream.readBits(7) + 11);

            while (N-- > 0 && i < TableSize) {
                Table[i++] = 0;
            }
        }
    }

    RarUtils.RarMakeDecodeTables(Table, 0, RarUtils.CONST.LD, RarUtils.CONST.rNC);
    RarUtils.RarMakeDecodeTables(Table, RarUtils.CONST.rNC, RarUtils.CONST.DD, RarUtils.CONST.rDC);
    RarUtils.RarMakeDecodeTables(Table, RarUtils.CONST.rNC + RarUtils.CONST.rDC, RarUtils.CONST.LDD, RarUtils.CONST.rLDC);
    RarUtils.RarMakeDecodeTables(Table, RarUtils.CONST.rNC + RarUtils.CONST.rDC + RarUtils.CONST.rLDC, RarUtils.CONST.RD, RarUtils.CONST.rRC);

    for (var i = UnpOldTable.length; i--;) {
        UnpOldTable[i] = Table[i];
    }
    return true;
}
233875
function compatibleTypes(x,y) {
	if (x === y)
		return true;
	if (x instanceof TQualifiedReference && y instanceof TQualifiedReference)
		return x.qname === y.qname;
	return false;
}
789843
function(oArgs) {
    if(oArgs.editor.disableBtns) {
        // Save on blur
        if(oArgs.editor.save) { // Backward incompatible
            oArgs.editor.save();
        }
    }      
    else if(oArgs.editor.cancel) { // Backward incompatible
        // Cancel on blur
        oArgs.editor.cancel();
    }      
}
741113
public static void Backward(double[] data) {

        double[] result = new double[data.length];
        double sum;
        double scale = Math.sqrt(2.0 / data.length);
        for (int t = 0; t < data.length; t++) {
            sum = 0;
            for (int j = 0; j < data.length; j++) {
                double cos = Math.cos(((2 * t + 1) * j * Math.PI) / (2 * data.length));
                sum += alpha(j) * data[j] * cos;
            }
            result[t] = scale * sum;
        }
        for (int i = 0; i < data.length; i++) {
            data[i] = result[i];
        }
    }
825973
@Override
    public void backward() {
        Tensor x = modInX.getOutput();
        Tensor w = modInW.getOutput();
        {
            Tensor tmp = new Tensor(yAdj); // copy
            tmp.elemDivide(w);
            correctForZeros(tmp);
            modInX.getOutputAdj().elemAdd(tmp);
        }
        {
            Tensor tmp = new Tensor(w); // copy
            tmp.fill(s.one());
            tmp.elemDivide(w);
            tmp.elemDivide(w);
            tmp.multiply(s.fromReal(-1));
            tmp.elemMultiply(yAdj);
            tmp.elemMultiply(x); 
            correctForZeros(tmp);
            modInW.getOutputAdj().elemAdd(tmp);
        }
    }
991663
@Override
    public boolean isHardFloatAbi() throws UnsupportedOperationException {
        return AccessController.doPrivileged(new PrivilegedAction<Boolean>() {
            private final String[] gnueabihf = new String[] { "gnueabihf", "armhf" };
            public Boolean run() {
                return ( StringUtil.contains(System.getProperty("sun.boot.library.path"), gnueabihf) ||
                        StringUtil.contains(System.getProperty("java.library.path"), gnueabihf) ||
                        StringUtil.contains(System.getProperty("java.home"), gnueabihf) ||
                        getBashVersionInfo().contains("gnueabihf") ||
                        hasReadElfTag("Tag_ABI_HardFP_use"));
            } } );
    }
1265293
public boolean compatiable(StreamInfo info) {
        if (sampleRate != info.sampleRate) return false;
        if (channels != info.channels) return false;
        if (bitsPerSample != info.bitsPerSample) return false;
        return true;
    }