Package rope.core

Class Rope

java.lang.Object
rope.core.Rope
All Implemented Interfaces:
R_Constants, R_Constants_Colour
Direct Known Subclasses:
BigBang, R_Colour, R_FX, R_Node, R_Nubo, R_Pix, R_Pixies, R_Plane

public class Rope extends Object implements R_Constants, R_Constants_Colour
  • Constructor Details

    • Rope

      public Rope()
  • Method Details

    • get_renderer

      public String get_renderer(processing.core.PGraphics graph)
    • getColorMode

      public float[] getColorMode(processing.core.PGraphics pg)
    • getColorMode

      public float[] getColorMode(processing.core.PGraphics pg, boolean print_info_is)
    • d_pow

      public float d_pow(float value, float threshold, float power)
    • d_sqrt

      public float d_sqrt(float value, float threshold)
    • d_cbrt

      public float d_cbrt(float value, float threshold)
    • d_sin

      public float d_sin(float value, float threshold, float ratio)
      Parameters:
      value -
      threshold -
      ratio - good value from 0 to 2
      Returns:
    • d_cos

      public float d_cos(float value, float threshold, float ratio)
      Parameters:
      value -
      threshold -
      ratio - good value from 0 to 2
      Returns:
    • d_bell

      public float d_bell(float value, float threshold, float variance, float offset)
      Parameters:
      value - in the range of threshold
      threshold - this value is used to calculate the normal value
      variance - usualy from 0 to 10
      offset - the value can be negative and she relative to the threshold
      Returns:
    • d_normal

      public float d_normal(float value, float threshold, float variance, float offset)
    • d_sigmoid

      public float d_sigmoid(float value, float threshold, float variance)
      Parameters:
      value -
      threshold -
      variance - value from 0.000001 to more, but the value between 0 to 1 is important. 1 is a average value.
      Returns:
    • add

      public vec2 add(vec2 a, vec2 b)
      each element add of each vector mult each one in the order
      Parameters:
      a - vector be added
      b - vector added
      Returns:
      result of the operation
    • add

      public vec3 add(vec3 a, vec3 b)
    • add

      public vec4 add(vec4 a, vec4 b)
    • add

      public vec2 add(vec2 a, float arg)
    • add

      public vec3 add(vec3 a, float arg)
    • add

      public vec4 add(vec4 a, float arg)
    • sub

      public vec2 sub(vec2 a, vec2 b)
      each element substract of each vector mult each one in the order
      Parameters:
      a - vector target
      b - vector must be sub
      Returns:
      result of the operation
    • sub

      public vec3 sub(vec3 a, vec3 b)
    • sub

      public vec4 sub(vec4 a, vec4 b)
    • sub

      public vec2 sub(vec2 a, float arg)
    • sub

      public vec3 sub(vec3 a, float arg)
    • sub

      public vec4 sub(vec4 a, float arg)
    • mult

      public vec2 mult(vec2 a, vec2 b)
      each element multipry of each vector mult each one in the order
      Parameters:
      a - vector multiplicator
      b - vector multiplicator
      Returns:
      result of the operation
    • mult

      public vec3 mult(vec3 a, vec3 b)
    • mult

      public vec4 mult(vec4 a, vec4 b)
    • mult

      public vec2 mult(vec2 a, float arg)
    • mult

      public vec3 mult(vec3 a, float arg)
    • mult

      public vec4 mult(vec4 a, float arg)
    • div

      public vec2 div(vec2 a, vec2 b)
      Parameters:
      a - vector must be divide by b
      b - vector must divide a
      Returns:
      result of the operation
    • div

      public vec3 div(vec3 a, vec3 b)
    • div

      public vec4 div(vec4 a, vec4 b)
    • div

      public vec2 div(vec2 a, float arg)
    • div

      public vec3 div(vec3 a, float arg)
    • div

      public vec4 div(vec4 a, float arg)
    • cross

      public vec3 cross(vec3 v1, vec3 v2)
      Cross product of vec3
      Parameters:
      v1 - coordinate
      v2 - coordinate
      Returns:
      result of the croos operation
    • constrain

      public int constrain(int amt, int low, int high)
      Constrains a value to not exceed a maximum and minimum value. math:calculation Constrains a value to not exceed a maximum and minimum value.
      Parameters:
      amt - the value to constrain
      low - minimum limit
      high - maximum limit
    • constrain

      public float constrain(float amt, float low, float high)
    • map

      public float map(float value, float start1, float stop1, float start2, float stop2)
      map method
      Parameters:
      value - value must be compute
      start1 - min range value of the starting field
      stop1 - max range value of the starting field
      start2 - min range value of the final field
      stop2 - max range value of the final field
      Returns:
      result of the scale map operation
    • map

      public vec2 map(vec2 value, float minIn, float maxIn, float minOut, float maxOut)
    • map

      public vec3 map(vec3 value, float minIn, float maxIn, float minOut, float maxOut)
    • map

      public vec4 map(vec4 value, float minIn, float maxIn, float minOut, float maxOut)
    • dist

      public float dist(float x1, float y1, float x2, float y2)
      Parameters:
      x1 - value x of the first point
      y1 - value y of the first point
      x2 - value x of the second point
      y2 - value y of the second point
      Returns:
      float distance beween the two points
    • dist

      public float dist(float x1, float y1, float z1, float x2, float y2, float z2)
      Parameters:
      x1 - value x of the first point
      y1 - value y of the first point
      z1 - value z of the first point
      x2 - value x of the second point
      y2 - value y of the second point
      z2 - value z of the second point
      Returns:
      float distance beween the two points
    • dist

      public float dist(vec2 a, vec2 b)
      Parameters:
      a - coordinate of the first point
      b - coordinate of the second point
      Returns:
      float distance beween the two points
    • dist

      public float dist(vec3 a, vec3 b)
      Parameters:
      a - coordinate of the first point
      b - coordinate of the second point
      Returns:
      float distance beween the two points
    • dist

      public float dist(vec4 a, vec4 b)
      Parameters:
      a - coordinate of the first point
      b - coordinate of the second point
      Returns:
      float distance beween the two points
    • in_segment

      public boolean in_segment(vec2 start, vec2 end, vec2 point, float range)
      Parameters:
      start -
      end -
      point -
      range -
      Returns:
      See Also:
    • in_segment

      public boolean in_segment(R_Line2D line, vec2 point, float marge)
      Parameters:
      line -
      point -
      marge -
      Returns:
    • in_line

      public boolean in_line(vec2 a, vec2 b, vec2 c, float marge)
      Check if the three points is aligned
      Parameters:
      a - point must be checked
      b - point must be checked
      c - point must be checked
      marge - pixel around the line to test is the points are aligned
      Returns:
    • in_line

      public boolean in_line(R_Line2D line, vec2 point, float marge)
      check if the point is aligned with the line
      Parameters:
      line -
      point -
      marge -
      Returns:
    • in_polygon

      public boolean in_polygon(vec[] points, vec pos)
      Parameters:
      points - list of coordinate of the shape
      pos - coordinate of value must be tested
      Returns:
      true is the position is in the shape
      See Also:
    • in_polygon

      public boolean in_polygon(R_Shape shape, vec pos)
    • in_polygon

      public byte in_polygon(vec[] points, vec pos, float marge)
      Parameters:
      points - cloud of points shape the polygon
      pos - of the point must be detected
      marge - distance of the point around the border
      Returns:
      -1 is out / 0 on border / 1 in polygon
    • in_polygon

      public byte in_polygon(R_Shape shape, vec pos, float marge)
    • to_cartesian_3D

      public vec3 to_cartesian_3D(vec2 pos, vec2 range, float size)
      *** ACHTUNG *** It's not clear must find time to work on explanation of this function If I remember is to compare to vec but not sure...
      Parameters:
      pos - ??? may be the angle
      range - ??? may be be the range of the vec ????
      size - ??? may be the distance to center ???
      Returns:
    • to_cartesian_3D

      public vec3 to_cartesian_3D(float latitude, float longitude)
      Parameters:
      latitude - latitude in radiant
      longitude - longitude in radiant
      Returns:
      the cartesian angle coordinate
    • to_cartesian_3D

      public vec3 to_cartesian_3D(float latitude, float longitude, float radius)
      main method to_cartesian_3D
      Parameters:
      latitude - latitude in radiant
      longitude - longitude in radiant
      radius - distance to center
      Returns:
      the cartesian angle coordinate
    • to_cartesian_2D

      public vec2 to_cartesian_2D(float pos, vec2 range, vec2 target_rad, float distance)
      *** ACHTUNG *** It's not clear must find time to work on explanation of this function If I remember is to compare to vec but not sure...
      Parameters:
      pos - ??? may be the angle
      range - ??? may be be the range of the first vec ????
      target_rad - ??? may be be the range of the last vec ????
      distance - distance to center
      Returns:
      the cartesian angle coordinate
    • to_cartesian_2D

      public vec2 to_cartesian_2D(float angle, float radius)
      Parameters:
      angle - radiant value
      radius - distance to center
      Returns:
      the cartesian angle coordinate
    • to_cartesian_2D

      public vec2 to_cartesian_2D(float angle)
      main method to_cartesian_2D
      Parameters:
      angle - radiant value
      Returns:
      the cartesian angle coordinate
    • barycenter

      public vec2 barycenter(vec2... v)
      Parameters:
      v - list coordinate to compute the barycenter
      Returns:
      coordinate of the barycenter
    • barycenter

      public vec3 barycenter(vec3... v)
      Parameters:
      v - list coordinate to compute the barycenter
      Returns:
      coordinate of the barycenter
    • barycenter

      public vec4 barycenter(vec4... vector)
      Parameters:
      vector - array coordinates to calculate the barycenter
      Returns:
      vec4 result
    • projection

      public vec2 projection(vec2 direction)
      Projection
      Parameters:
      direction - vec2 radiant direction
      Returns:
      coordinate of the point
    • projection

      public vec2 projection(vec2 direction, float radius)
      Parameters:
      direction - vec2 radiant direction
      radius - distance for the projection
      Returns:
      coordinate of the point
    • projection

      public vec2 projection(vec2 direction, vec2 origin, float radius)
      Parameters:
      direction - vec2 radiant direction
      origin - position
      radius - distance for the projection
      Returns:
      coordinate of the point
    • projection

      public vec2 projection(float angle)
      polar projection 2D
      Parameters:
      angle - float radiant direction
      Returns:
      coordinate of the point
    • projection

      public vec2 projection(float angle, float radius)
      Parameters:
      angle - float radiant direction
      radius - distance for the projection
      Returns:
      coordinate of the point
    • projection

      public vec3 projection(vec3 direction)
      Cartesian projection 3D
      Parameters:
      direction - vec2 radiant direction
      Returns:
      coordinate of the point
    • projection

      public vec3 projection(vec3 direction, float radius)
      Parameters:
      direction - vec2 radiant direction
      radius - distance for the projection
      Returns:
      coordinate of the point
    • projection

      public vec3 projection(vec3 direction, vec3 origin, float radius)
      Parameters:
      direction - vec2 radiant direction
      origin - position
      radius - distance for the projection
      Returns:
      coordinate of the point
    • random

      public float random(float high)
      Parameters:
      high - define value max for the random
      Returns:
      random number, this method is a copy of Processing one
    • random

      public float random(float low, float high)
      Parameters:
      low - define value min for the random
      high - define value max for the random
      Returns:
      random number, this method is a copy of Processing one
    • random_next_gaussian

      public float random_next_gaussian(int n)
      Parameters:
      n - the num of operation must iterate each operation is mult by the previous result
      Returns:
      random value
    • random_next_gaussian

      public float random_next_gaussian(float range)
      Parameters:
      range - define value max for the random
      Returns:
      random value
    • random_next_gaussian

      public float random_next_gaussian(float range, int n)
      Parameters:
      range - represente the max value possible from 0 to this value.
      n - the num of operation must iterate each operation is mult by the previous result
      Returns:
      random value
    • reverse

      public <T> T[] reverse(T[] arr)
    • reverse

      public boolean[] reverse(boolean[] arr)
    • reverse

      public byte[] reverse(byte[] arr)
    • reverse

      public char[] reverse(char[] arr)
    • reverse

      public int[] reverse(int[] arr)
    • reverse

      public long[] reverse(long[] arr)
    • reverse

      public float[] reverse(float[] arr)
    • reverse

      public double[] reverse(double[] arr)
    • reverse

      public String[] reverse(String[] arr)
    • max

      public float max(float... list)
      Parameters:
      list - list of arguments must be sorted
      Returns:
      the max value of the list
    • max

      public int max(int... list)
    • max

      public vec2 max(vec2 a, vec2 b)
    • max

      public vec3 max(vec3 a, vec3 b)
    • max

      public vec4 max(vec4 a, vec4 b)
    • max

      public ivec2 max(ivec2 a, ivec2 b)
    • max

      public ivec3 max(ivec3 a, ivec3 b)
    • max

      public ivec4 max(ivec4 a, ivec4 b)
    • min

      public float min(float... list)
      Parameters:
      list - list of arguments must be sorted
      Returns:
      the min value of the list
    • min

      public int min(int... list)
    • min

      public vec2 min(vec2 a, vec2 b)
    • min

      public vec3 min(vec3 a, vec3 b)
    • min

      public vec4 min(vec4 a, vec4 b)
    • min

      public ivec2 min(ivec2 a, ivec2 b)
    • min

      public ivec3 min(ivec3 a, ivec3 b)
    • min

      public ivec4 min(ivec4 a, ivec4 b)
    • abs

      public float abs(float arg)
      Parameters:
      arg - passed to be transform
      Returns:
      absolute value
    • abs

      public int abs(int arg)
    • abs

      public vec2 abs(vec2 arg)
    • abs

      public vec3 abs(vec3 arg)
    • abs

      public vec4 abs(vec4 arg)
    • abs

      public ivec2 abs(ivec2 arg)
    • abs

      public ivec3 abs(ivec3 arg)
    • abs

      public ivec4 abs(ivec4 arg)
    • floor

      public int floor(float value)
      Parameters:
      value - must be transform
      Returns:
      return int rounded to down
    • floor

      public vec2 floor(vec2 arg)
    • floor

      public vec3 floor(vec3 arg)
    • floor

      public vec4 floor(vec4 arg)
    • ceil

      public int ceil(float value)
      Parameters:
      value - must be transform
      Returns:
      int rounded to up
    • ceil

      public vec2 ceil(vec2 arg)
    • ceil

      public vec3 ceil(vec3 arg)
    • ceil

      public vec4 ceil(vec4 arg)
    • round

      public int round(float value)
      Parameters:
      value - must be transform
      Returns:
      value average rounded value to int.
    • round

      public vec2 round(vec2 arg)
    • round

      public vec3 round(vec3 arg)
    • round

      public vec4 round(vec4 arg)
    • sq

      public float sq(float value)
      Parameters:
      value - must be squared
      Returns:
      the result of the operation
    • sqrt

      public float sqrt(float value)
      Parameters:
      value - value to compute the squareroot
      Returns:
      the result of the operation
    • pow

      public float pow(float arg, float exp)
      Parameters:
      arg - value must be transform by the exp
      exp - it's the exponent value to powered
      Returns:
      value powered by n
    • atan

      public float atan(float value)
      Parameters:
      value - value to compute
      Returns:
      the result of the operation
    • cos

      public float cos(float value)
      Parameters:
      value - to compute
      Returns:
      the result of the operation
    • sin

      public float sin(float value)
      Parameters:
      value - to compute
      Returns:
      the result of the operation
    • mix

      public float mix(float x, float y, float a)
      Parameters:
      x - elem to mix
      y - elem to mix
      a - mixer element
      Returns:
      the mix result
      See Also:
    • mix

      public vec2 mix(vec2 x, vec2 y, vec2 a)
    • mix

      public vec3 mix(vec3 x, vec3 y, vec3 a)
    • mix

      public vec4 mix(vec4 x, vec4 y, vec4 a)
    • fract

      public float fract(float x)
      Parameters:
      x - value to fract
      Returns:
      fract result
      See Also:
    • fract

      public vec2 fract(vec2 v)
    • fract

      public vec3 fract(vec3 v)
    • fract

      public vec4 fract(vec4 v)
    • sign

      public float sign(float x)
      Parameters:
      x - value who find sign
      Returns:
      value -1, 0 or 1
      See Also:
    • sign

      public vec2 sign(vec2 x)
    • sign

      public vec3 sign(vec3 x)
    • sign

      public vec4 sign(vec4 x)
    • sign

      public int sign(int x)
    • sign

      public ivec2 sign(ivec2 x)
    • sign

      public ivec3 sign(ivec3 x)
    • sign

      public ivec4 sign(ivec4 x)
    • step

      public float step(float edge, float x)
      Parameters:
      edge - the smooth edge
      x - value to smooth
      Returns:
      the result of the operation
      See Also:
    • step

      public vec2 step(vec2 edge, vec2 x)
    • step

      public vec3 step(vec3 edge, vec3 x)
    • step

      public vec4 step(vec4 edge, vec4 x)
    • smoothstep

      public float smoothstep(float edge0, float edge1, float x)
      Parameters:
      edge0 - the smooth first edge
      edge1 - the smooth second edge
      x - value to smooth
      Returns:
      the result of the operation
      See Also:
    • smoothstep

      public vec2 smoothstep(vec2 edge0, vec2 edge1, vec2 x)
    • smoothstep

      public vec3 smoothstep(vec3 edge0, vec3 edge1, vec3 x)
    • smoothstep

      public vec4 smoothstep(vec4 edge0, vec4 edge1, vec4 x)
    • mod

      public float mod(float x, float y)
      Parameters:
      x - value to mod
      y - value to mod
      Returns:
      result of operation
      See Also:
    • mod

      public vec2 mod(vec2 x, vec2 y)
    • mod

      public vec3 mod(vec3 x, vec3 y)
    • mod

      public vec4 mod(vec4 x, vec4 y)
    • mod

      public ivec2 mod(ivec2 x, ivec2 y)
    • mod

      public ivec3 mod(ivec3 x, ivec3 y)
    • mod

      public ivec4 mod(ivec4 x, ivec4 y)
    • clamp

      public float clamp(float x, float min, float max)
      Parameters:
      x - value to clamp
      min - the min value available
      max - the max value available
      Returns:
      reslut of operation
      See Also:
    • clamp

      public vec2 clamp(vec2 x, vec2 min, vec2 max)
    • clamp

      public vec3 clamp(vec3 x, vec3 min, vec3 max)
    • clamp

      public vec4 clamp(vec4 x, vec4 min, vec4 max)
    • compare

      public boolean compare(float x, float y, float area)
    • compare

      public boolean compare(vec2 x, vec2 y, vec2 area)
    • compare

      public boolean compare(vec3 x, vec3 y, vec3 area)
    • compare

      public boolean compare(vec4 x, vec4 y, vec4 area)
    • compare

      public boolean compare(int x, int y, int area)
    • compare

      public boolean compare(ivec2 x, ivec2 y, ivec2 area)
    • compare

      public boolean compare(ivec3 x, ivec3 y, ivec3 area)
    • compare

      public boolean compare(ivec4 x, ivec4 y, ivec4 area)
    • equal

      public boolean equal(float x, float y)
      Parameters:
      x - float value to test
      y - float value to test
      Returns:
      true if x equal to y
      See Also:
    • equal

      public boolean equal(int x, int y)
    • equal

      public bvec2 equal(vec2 x, vec2 y)
    • equal

      public bvec3 equal(vec3 x, vec3 y)
    • equal

      public bvec4 equal(vec4 x, vec4 y)
    • equal

      public bvec2 equal(ivec2 x, ivec2 y)
    • equal

      public bvec3 equal(ivec3 x, ivec3 y)
    • equal

      public bvec4 equal(ivec4 x, ivec4 y)
    • lessThan

      public boolean lessThan(float x, float y)
      Parameters:
      x - float value to test
      y - float value to test
      Returns:
      true if x inferior to y
      See Also:
    • lessThan

      public boolean lessThan(int x, int y)
    • lessThan

      public bvec2 lessThan(vec2 x, vec2 y)
    • lessThan

      public bvec3 lessThan(vec3 x, vec3 y)
    • lessThan

      public bvec4 lessThan(vec4 x, vec4 y)
    • lessThan

      public bvec2 lessThan(ivec2 x, ivec2 y)
    • lessThan

      public bvec3 lessThan(ivec3 x, ivec3 y)
    • lessThan

      public bvec4 lessThan(ivec4 x, ivec4 y)
    • greaterThan

      public boolean greaterThan(float x, float y)
      Parameters:
      x - float value to test
      y - float value to test
      Returns:
      true if x superior to y
    • greaterThan

      public boolean greaterThan(int x, int y)
    • greaterThan

      public bvec2 greaterThan(vec2 x, vec2 y)
    • greaterThan

      public bvec3 greaterThan(vec3 x, vec3 y)
    • greaterThan

      public bvec4 greaterThan(vec4 x, vec4 y)
    • greaterThan

      public bvec2 greaterThan(ivec2 x, ivec2 y)
    • greaterThan

      public bvec3 greaterThan(ivec3 x, ivec3 y)
    • greaterThan

      public bvec4 greaterThan(ivec4 x, ivec4 y)
    • greaterThanEqual

      public boolean greaterThanEqual(float x, float y)
      Parameters:
      x - float value to test
      y - float value to test
      Returns:
      true if x superior or equal to y
      See Also:
    • greaterThanEqual

      public boolean greaterThanEqual(int x, int y)
    • greaterThanEqual

      public bvec2 greaterThanEqual(vec2 x, vec2 y)
    • greaterThanEqual

      public bvec3 greaterThanEqual(vec3 x, vec3 y)
    • greaterThanEqual

      public bvec4 greaterThanEqual(vec4 x, vec4 y)
    • greaterThanEqual

      public bvec2 greaterThanEqual(ivec2 x, ivec2 y)
    • greaterThanEqual

      public bvec3 greaterThanEqual(ivec3 x, ivec3 y)
    • greaterThanEqual

      public bvec4 greaterThanEqual(ivec4 x, ivec4 y)
    • lessThanEqual

      public boolean lessThanEqual(float x, float y)
      Parameters:
      x - float value to test
      y - float value to test
      Returns:
      true if x inferior or equal to y
      See Also:
    • lessThanEqual

      public boolean lessThanEqual(int x, int y)
    • lessThanEqual

      public bvec2 lessThanEqual(vec2 x, vec2 y)
    • lessThanEqual

      public bvec3 lessThanEqual(vec3 x, vec3 y)
    • lessThanEqual

      public bvec4 lessThanEqual(vec4 x, vec4 y)
    • lessThanEqual

      public bvec2 lessThanEqual(ivec2 x, ivec2 y)
    • lessThanEqual

      public bvec3 lessThanEqual(ivec3 x, ivec3 y)
    • lessThanEqual

      public bvec4 lessThanEqual(ivec4 x, ivec4 y)
    • all

      public boolean all(bvec b)
      Parameters:
      b - bvec value to test
      Returns:
      true only if all components of x are true.
      See Also:
    • all

      public boolean all(boolean... list)
      Parameters:
      list -
      Returns:
      true if all elments of the list is true
    • any

      public boolean any(bvec b)
      Parameters:
      b - bvec value to test https://www.khronos.org/registry/OpenGL/specs/gl
      Returns:
      true if any component of x is true.
    • any

      public boolean any(boolean... list)
      Parameters:
      list - boolean list value to test
      Returns:
      return true if any element of the list is true
    • only

      public boolean only(bvec b)
      Parameters:
      b - bvec value to test
      Returns:
      true is only one elements of the list is true
    • only

      public boolean only(boolean... list)
    • index_pixel_array

      public int index_pixel_array(int x, int y, int width)
      Parameters:
      x - coordinate x
      y - coordinate y
      width - the width of you 2D array pixel
      Returns:
      a linear position from a 2D array tab
    • truncate

      public float truncate(float x)
    • truncate

      public float truncate(float x, int num)
      Parameters:
      x - value to work
      num - after coma to display
      Returns:
      a float number with a number after comma equal to the num arg
    • hex

      public String hex(byte value)
    • hex

      public String hex(char value)
    • hex

      public String hex(int value)
    • hex

      public String hex(int value, int digits)
      Parameters:
      value - value to convert
      digits - the number of digits (maximum 8)
      Returns:
      String hexadecimal value
    • unhex

      public int unhex(String value)
      Converts a Stringrepresentation of a hexadecimal number to its equivalent integer value.
      Parameters:
      value - value to convert
      Returns:
      unhexadecimal int value
    • binary

      public String binary(byte value)
    • binary

      public String binary(char value)
    • binary

      public String binary(int value)
    • binary

      public String binary(int value, int digits)
      Converts an int, byte, char, or color to a String containing the equivalent binary notation. For example, the color value produced by color(0, 102, 153, 255) will convert to the String value "11111111000000000110011010011001". This function can help make your geeky debugging sessions much happier. Note that the maximum number of digits is 32, because an int value can only represent up to 32 bits. Specifying more than 32 digits will have no effect. .
      Parameters:
      value - value to convert
      digits - number of digits to return
      Returns:
      String binary
    • unbinary

      public int unbinary(String value)
    • split

      public String[] split(String value, char delim)
      Parameters:
      value -
      delim -
      Returns:
    • split

      public String[] split(String value, String delim)
      Parameters:
      value - is the sentence must be spited
      delim - is a separator
      Returns:
      array String of the String argument sentence
    • file_name

      public String file_name(String file_path)
      remove the path of your String to return the file name of it.
      Parameters:
      file_path -
      Returns:
    • get_os

      public String get_os()
      Returns:
      the current os
    • get_os_family

      public String get_os_family()
      Returns:
      the current os family
    • extension

      public String extension(String filename)
      Parameters:
      filename - check the last part of String path to return the extension if there is one
      Returns:
      the extension of the file
    • extension_is

      public boolean extension_is(String filename, String... extension)
      Parameters:
      filename - check the last part of String path return true at the first extension who match
      extension - list of extension must be check;
      Returns: