Sets this shape's shear

@param offset
@return T
17329
@Override
    public T setShear(final double x, final double y)
    {
        getAttributes().setShear(x, y);

        return cast();
    }
1360100
public function alignOffset($offset = 0)
    {
        // Return value
        if (empty($offset)) {
            return $this->alignOffset;
        }

        // Set value
        $this->alignOffset = $offset;

        return $this;
    }
1211077
@Override
    public C setOffset(final double x, final double y)
    {
        getAttributes().setOffset(x, y);

        return cast();
    }
658864
public void addDwgObjectOffset( int handle, int offset ) {
        DwgObjectOffset doo = new DwgObjectOffset(handle, offset);
        dwgObjectOffsets.add(doo);
    }
923096
public void setValue(float angle, float x, float y, float z) {
        set(angle, x, y, z);
    }
1325213
function set (buffer, offset, value) {
  debug('Struct "type" setter for buffer at offset', buffer, offset, value)
  var isStruct = value instanceof this
  if (isStruct) {
    // optimization: copy the buffer contents directly rather
    // than going through the ref-struct constructor
    value['ref.buffer'].copy(buffer, offset, 0, this.size)
  } else {
    if (offset > 0) {
      buffer = buffer.slice(offset)
    }
    new this(buffer, value)
  }
}
624076
public AxisAngle4d set(double angle, double x, double y, double z) {
        this.x = x;
        this.y = y;
        this.z = z;
        this.angle = (angle < 0.0 ? Math.PI + Math.PI + angle % (Math.PI + Math.PI) : angle) % (Math.PI + Math.PI);
        return this;
    }
445030
private static boolean isAPortOffset(int offset) {
    return (offset == STANDARD_ASCII_PORT_OFFSET)
                   || (offset == STANDARD_HTTP_PORT_OFFSET)
                   || (offset == STANDARD_SERVLET_PORT_OFFSET)
                   || (offset == STANDARD_CFASL_PORT_OFFSET);
  }
414609
public static int addOffset(int index, int offset, int size) {
		index += offset;
		if( index < 0 ) {
			return size + index;
		} else {
			return index%size;
		}
	}
31418
public void set(Segment1D<?, ?> segment, double curviline, double shift) {
		assert segment != null : AssertMessages.notNullParameter(0);
		this.segment = new WeakReference<>(segment);
		this.x = curviline;
		this.y = shift;
	}
373059
public SliceValue getValueForAngle(int angle, SelectedValue selectedValue) {
        final PieChartData data = dataProvider.getPieChartData();
        final float touchAngle = (angle - rotation + 360f) % 360f;
        final float sliceScale = 360f / maxSum;
        float lastAngle = 0f;
        int sliceIndex = 0;
        for (SliceValue sliceValue : data.getValues()) {
            final float tempAngle = Math.abs(sliceValue.getValue()) * sliceScale;
            if (touchAngle >= lastAngle) {
                if (null != selectedValue) {
                    selectedValue.set(sliceIndex, sliceIndex, SelectedValueType.NONE);
                }
                return sliceValue;
            }
            lastAngle += tempAngle;
            ++sliceIndex;
        }
        return null;
    }
874928
public function setOffset($offset)
    {
        $this->offset = $offset === null ? null : (int) $offset;
        return $this;
    }
1030320
public static MutableRoaringBitmap addOffset(final ImmutableRoaringBitmap x, int offset) {
    int container_offset = offset >>> 16;
    int in_container_offset = offset % (1<<16);
    if(in_container_offset == 0) {
      MutableRoaringBitmap answer = x.toMutableRoaringBitmap();
      for(int pos = 0; pos < answer.highLowContainer.size(); pos++) {
        int key = BufferUtil.toIntUnsigned(answer.getMappeableRoaringArray()
            .getKeyAtIndex(pos));
        key += container_offset;
        if(key > 0xFFFF) {
          throw new IllegalArgumentException("Offset too large.");
        }
        answer.getMappeableRoaringArray().keys[pos] = (short) key;
      }
      return answer;
    } else {
      MutableRoaringBitmap answer = new MutableRoaringBitmap();
      for(int pos = 0; pos < x.highLowContainer.size(); pos++) {
        int key = BufferUtil.toIntUnsigned(x.highLowContainer.getKeyAtIndex(pos));
        key += container_offset;
        if(key > 0xFFFF) {
          throw new IllegalArgumentException("Offset too large.");
        }
        MappeableContainer c = x.highLowContainer.getContainerAtIndex(pos);
        MappeableContainer[] offsetted = BufferUtil.addOffset(c, 
          (short)in_container_offset);
        if( !offsetted[0].isEmpty()) {
          int current_size = answer.highLowContainer.size();
          int lastkey = 0;
          if(current_size > 0) {
            lastkey = answer.highLowContainer.getKeyAtIndex(
              current_size - 1);
          }
          if((current_size > 0) && (lastkey == key)) {
            MappeableContainer prev = answer.highLowContainer
                .getContainerAtIndex(current_size - 1);
            MappeableContainer orresult = prev.ior(offsetted[0]);
            answer.getMappeableRoaringArray().setContainerAtIndex(current_size - 1,
                orresult);
          } else {
            answer.getMappeableRoaringArray().append((short)key, offsetted[0]);
          }
        }
        if( !offsetted[1].isEmpty()) {
          if(key == 0xFFFF) {
            throw new IllegalArgumentException("Offset too large.");
          }
          answer.getMappeableRoaringArray().append((short)(key + 1), offsetted[1]);
        }
      }
      answer.repairAfterLazy();
      return answer;
    }
  }
1347922
public AxisAngle4f set(float angle, Vector3fc v) {
        return set(angle, v.x(), v.y(), v.z());
    }
655657
function shear(shx, shy) {
    return {
        a: 1, c: shx, e: 0,
        b: shy, d: 1, f: 0
    };
}
1174789
public void offsetTo(float newLeft, float newTop) {
        right += newLeft - left;
        bottom += newTop - top;
        left = newLeft;
        top = newTop;
    }
1325389
def set_offset(self, offset):
        

        if not isinstance(offset, int) or offset < 0:
            raise DaftException("Offset should be a positive integer.")

        self._offset = str(offset)