# Source code for sas.sasgui.plottools.transform

import math

[docs]def toX(x, y=None):
"""
This function is used to load value on Plottable.View

:param x: Float value

:return: x

"""
return x

[docs]def toX_pos(x, y=None):
"""
This function is used to load value on Plottable.View

:param x: Float value

:return: x

"""
if not x > 0:
raise ValueError, "Transformation only accepts positive values."
else:
return x

[docs]def toX2(x, y=None):
"""
This function is used to load value on Plottable.View

Calculate x^(2)

:param x: float value

"""
return x * x

[docs]def fromX2(x, y=None):
"""
This function is used to load value on Plottable.View
Calculate square root of x

:param x: float value

"""
if not x >= 0:
raise ValueError, "square root of a negative value "
else:
return math.sqrt(x)

[docs]def toX4(x, y=None):
"""
This function is used to load value on Plottable.View

Calculate x^(4)

:param x: float value

"""
return x * x * x * x

[docs]def fromX4(x, y=None):
"""
This function is used to load value on Plottable.View
Calculate square root of x

:param x: float value

"""
if not x >= 0:
raise ValueError, "double square root of a negative value "
else:
return math.sqrt(math.sqrt(x))

[docs]def toLogX(x, y=None):
"""
This function is used to load value on Plottable.View
calculate log x

:param x: float value

"""
if not x > 0:
raise ValueError, "Log(x)of a negative value "
else:
return math.log(x)

[docs]def toOneOverX(x, y=None):
"""
"""
if x != 0:
return 1 / x
else:
raise ValueError, "cannot divide by zero"

[docs]def toOneOverSqrtX(y, x=None):
"""
"""
if y > 0:
return 1 / math.sqrt(y)
else:
raise ValueError, "transform.toOneOverSqrtX: cannot be computed"

[docs]def toLogYX2(y, x):
"""
"""
if (y * (x ** 2)) > 0:
return math.log(y * (x ** 2))
else:
raise ValueError, "transform.toLogYX2: cannot be computed"

[docs]def toLogYX4(y, x):
"""
"""
if (math.pow(x, 4) * y) > 0:
return math.log(math.pow(x, 4) * y)
else:
raise ValueError, "transform.toLogYX4: input error"

[docs]def toYX4(y, x):
"""
"""
return math.pow(x, 4) * y

[docs]def toYX2(y, x):
"""
"""
return math.pow(x, 2) * y

[docs]def toLogXY(y, x):
"""
This function is used to load value on Plottable.View
calculate log x

:param x: float value

"""
if not (x * y) > 0:
raise ValueError, "Log(X*Y)of a negative value "
else:
return math.log(x * y)

[docs]def errToX(x, y=None, dx=None, dy=None):
"""
calculate error of x**2

:param x: float value
:param dx: float value

"""
if dx == None:
dx = 0
return dx

[docs]def errToX_pos(x, y=None, dx=None, dy=None):
"""
calculate error of x**2

:param x: float value
:param dx: float value

"""
if dx == None:
dx = 0
return dx

[docs]def errToX2(x, y=None, dx=None, dy=None):
"""
calculate error of x**2

:param x: float value
:param dx: float value

"""
if  dx != None:
err = 2 * x * dx
return math.fabs(err)
else:
return 0.0

[docs]def errFromX2(x, y=None, dx=None, dy=None):
"""
calculate error of sqrt(x)

:param x: float value
:param dx: float value

"""
if x > 0:
if dx != None:
err = dx / (2 * math.sqrt(x))
else:
err = 0
return math.fabs(err)
else:
msg = "transform.errFromX2: can't compute error of negative x"
raise ValueError, msg

[docs]def errToX4(x, y=None, dx=None, dy=None):
"""
calculate error of x**4

:param x: float value
:param dx: float value

"""
if dx != None:
err = 4 * math.pow(x, 3) * dx
return math.fabs(err)
else:
return 0.0

[docs]def errFromX4(x, y=None, dx=None, dy=None):
"""
calculate error of x^1/4

:param x: float value
:param dx: float value

"""
if x > 0:
if dx != None:
err = dx / (4 * math.pow(x, 3 / 4))
else:
err = 0
return math.fabs(err)
else:
msg = "transform.errFromX4: can't compute error of negative x"
raise ValueError, msg

[docs]def errToLog10X(x, y=None, dx=None, dy=None):
"""
calculate error of Log(x)

:param x: float value
:param dx: float value

"""
if dx == None:
dx = 0

# Check that the point on the graph is positive
# within errors
if not (x - dx) > 0:
msg = "Transformation does not accept"
msg += " point that are consistent with zero."
raise ValueError, msg
if x != 0:
dx = dx / (x * math.log(10))
else:
raise ValueError, "errToLogX: divide by zero"
return dx

[docs]def errToLogX(x, y=None, dx=None, dy=None):
"""
calculate error of Log(x)

:param x: float value
:param dx: float value

"""
if dx == None:
dx = 0

# Check that the x point on the graph is zero
if x != 0:
dx = dx / x
else:
raise ValueError, "errToLogX: divide by zero"
return dx

[docs]def errToYX2(y, x, dy=None, dx=None):
"""
"""
if dx == None:
dx = 0
if dy == None:
dy = 0
err = math.sqrt((2 * x * y * dx) ** 2 + ((x ** 2) * dy) ** 2)
return err

[docs]def errToLogXY(x, y, dx=None, dy=None):
"""
calculate error of Log(xy)

"""
# Check that the point on the graph is positive
# within errors
if not (x - dx) > 0 or not (y - dy) > 0:
msg = "Transformation does not accept point "
msg += " that are consistent with zero."
raise ValueError, msg
if x != 0 and y != 0:
if dx == None:
dx = 0
if dy == None:
dy = 0
err = (dx / x) ** 2 + (dy / y) ** 2
else:
raise ValueError, "cannot compute this error"

return math.sqrt(math.fabs(err))

[docs]def errToLogYX2(y, x, dy=None, dx=None):
"""
calculate error of Log(yx**2)

"""
# Check that the point on the graph is positive
# within errors
if not (x - dx) > 0 or not (y - dy) > 0:
msg = "Transformation does not accept point"
msg += " that are consistent with zero."
raise ValueError, msg
if x > 0 and y > 0:
if dx == None:
dx = 0
if dy == None:
dy = 0
err = (2.0 * dx / x) ** 2 + (dy / y) ** 2
else:
raise ValueError, "cannot compute this error"
return math.sqrt(math.fabs(err))

[docs]def errOneOverX(x, y=None, dx=None, dy=None):
"""
calculate error on 1/x

"""
if x != 0:
if dx == None:
dx = 0
err = dx / x ** 2
else:
raise ValueError, "Cannot compute this error"
return math.fabs(err)

[docs]def errOneOverSqrtX(x, y=None, dx=None, dy=None):
"""
Calculate error on 1/sqrt(x)

"""
if x > 0:
if dx == None:
dx = 0
err = -1 / 2 * math.pow(x, -3.0 / 2.0) * dx
else:
raise ValueError, "Cannot compute this error"
return math.fabs(err)

[docs]def errToLogYX4(y, x, dy=None, dx=None):
"""
error for ln(y*x^(4))

:param x: float value

"""
# Check that the point on the graph is positive
# within errors
if (not (x - dx) > 0) or (not (y - dy) > 0):
msg = "Transformation does not accept point "
msg += " that are consistent with zero."
raise ValueError, msg
if dx == None:
dx = 0
if dy == None:
dy = 0
err = math.sqrt((4.0 * dx / x) ** 2 + (dy / y) ** 2)
return err

[docs]def errToYX4(y, x, dy=None, dx=None):
"""
error for (y*x^(4))

:param x: float value

"""
# Check that the point on the graph is positive
# within errors

if dx == None:
dx = 0
if dy == None:
dy = 0
err = math.sqrt((dy * pow(x, 4)) ** 2 + (4 * y * dx * math.pow(x, 3)) ** 2)
return err