# 1.6.4.7: Changing data- basics of transformations - Mathematics

In complicated studies involving many data types: measurements and ranks, percentages and counts, parametric, nonparametric and nominal, it is useful to unify them. Another, more common way, is to treat discrete data as continuous—it is usually safe, but sometimes may lead to unpleasant surprises.

Another possibility is to transform measurement data into ranked. R function cut() allows to perform this operation and create ordered factors.

What is completely unacceptable is transforming common nominal data into ranks. If values are not, by their nature, ordered, imposing an artificial order can make the results meaningless.

Data are often transformed to make them closer to parametric and to homogenize standard deviations. Distributions with long tails, or only somewhat bell-shaped (as in Figure 4.2.5), might be log-transformed. It is perhaps the most common transformation.

There is even a special argument plot(..., log="axis"), where "axis" should be substituted with x or y, presenting it in (natural) logarithmic scale. Another variant is to simply calculate logarithm on the fly like plot(log(...).

Consider some widely used transformations and their implications in R(we assume that your measurements are recorded in the vector data):

• Logarithmic: log(data + 1). It may normalize distributions with positive skew (right-tailed), bring relationships between variables closer to linear and equalize variances. It cannot handle zeros, this is why we added a single digit.
• Square root: sqrt(data). It is similar to logarithmic in its effects, but cannot handle negatives.
• Inverse: 1/(data + 1). This one stabilizes variances, cannot handle zeros.
• Square: data^2. Together with square root, belongs to family of power transformations. It may normalize data with negative skew (left-tailed) data, bring relationships between variables closer to linear and equalize variances.
• Logit: log(p/(1-p)). It is mostly used on proportions to linearize S-shaped, or sigmoid, curves. Along with logit, these types of data are sometimes treated with arcsine transformation which is asin(sqrt(p)). In both cases, p must be between 0 and 1.

While working with multiple variables, keep track of their dimensions. Try not to mix them up, recording one variable in millimeters, and another in centimeters. Nevertheless, in multivariate statistics even data measured in common units might have different nature. In this case, variables are often standardized, e.g. brought to the same mean and/or the same variance with scale() function. Embedded trees data is a good example:

Code (PageIndex{1}) (R):

At the end of data types explanation, we recommend to review a small chart which could be helpful for the determination of data type (Figure (PageIndex{1})).

Figure (PageIndex{1}) How to tell the kind of data.

## Essential Math for Data Science: New Chapters

First, I changed the structure of the book: a first chapter on basic algebra has been removed. Part of old chapter 02 has been merged in the linear algebra part.

I restructured the table of content: I removed some content about very basic math (like what is an equation or a function) to have more space to cover slighly more advanced contents. The part Statistics and Probability is now at the beginning of the book (just after a first part on Calculus). Have a look at the new TOC below to have more details.

Here is the table of content. Click on the chapters to see what’s inside.

### Table of Content

#### PART 1. Calculus

Area under the curve

2.1.2 Mathematical Definition of Derivatives

2.1.3 Derivatives of Linear And Nonlinear Functions

2.2.3 Mathematical Definition

2.3.2 Derivative of the Cost Function

2.3.4 MSE Cost Function With Two Parameters

#### PART 2. Statistics and Probability

Joint and Marginal Probability

3.1.1 Variance and Standard Deviation

3.1.2 Covariance and Correlation

3.2.1 Definitions and Notation

3.2.2 Discrete and Continuous Random Variables

3.3.1 Probability Mass Functions

3.3.2 Probability Density Functions

2.3.4 MSE Cost Function With Two Parameters

3.4.3 Conditional Probability

3.6.1 Discrete Random Variables

3.6.2 Continuous Random Variables

3.6.3 Variance of Random Variables

3.7.1 Continuous Distribution

3.7.2 Discrete Distribution

Gaussian Distributions

4.4.2 Graphical Representation

4.5.1 Mathematical Definition

4.6.1 Derivation from the Poisson Distribution

Bayesian Inference

5.1.1 Mathematical Formulation

5.1.3 Bayesian Interpretation

5.1.4 Bayes’ Theorem with Distributions

5.2.1 Introduction and Notation

5.2.2 Finding the Parameters of the Distribution

5.2.3 Maximum Likelihood Estimation

5.3.4 Kullback-Leibler Divergence (KL Divergence)

#### PART 3. Linear Algebra

L1 Regularization. Effect of Lambda.

6.1.1 Geometric and Coordinate Vectors

6.2.1 Scalar Multiplication

6.4.2 Geometric interpretation: Projections

6.5.2 Effect of Regularization on Polynomial Regression

6.5.3 Differences between $L^1$ and $L^2$ Regularization

Scalars, vectors, matrices and tensors

7.3.1 Matrices with Vectors

7.3.3 Transpose of a Matrix Product

7.5.1 Images as Multi-dimensional Arrays

All linear Combinations of two vectors

8.1.2 Linear Transformations as Vectors and Matrices

8.1.3 Geometric Interpretation

8.2.2 All combinations of vectors

8.3.2 Subspaces of a Matrix

8.4.1 Geometric Interpretation

8.5.2 Linear Combination of Basis Vectors

Projection of a vector onto a plane

9.1.4 Representation of Linear Equations With Matrices

9.2.1 Overdetermined Systems of Equations

9.2.2 Underdetermined Systems of Equations

9.3.1 Solving Systems of Equations

9.3.2 Projections to Approximate Unsolvable Systems

9.3.3 Projections Onto a Line

9.3.4 Projections Onto a Plane

9.4.1 Linear Regression Using the Normal Equation

9.4.2 Relationship Between Least Squares and the Normal Equation

Principal Component Analysis on audio samples.

10.2.1 Linear Combinations of the Basis Vectors

10.2.2 The Change of Basis Matrix

10.2.3 Example: Changing the Basis of a Vector

10.3.1 Transformation Matrix

10.3.2 Transformation Matrix in Another Basis

10.4.1 First Step: Change of Basis

10.4.2 Eigenvectors and Eigenvalues

10.4.4 Eigendecomposition of Symmetric Matrices

10.5.2 Making Sense of Audio

SVD Geometry

11.1.1 Different Input and Output Spaces

11.1.2 Specifying the Bases

11.1.3 Eigendecomposition is Only for Square Matrices

11.2.1 From Eigendecomposition to SVD

11.2.2 Singular Vectors and Singular Values

11.2.3 Finding the Singular Vectors and the Singular Values

11.3.1 Two-Dimensional Example

11.3.2 Comparison with Eigendecomposition

11.3.3 Three-Dimensional Example

11.4.1 Full SVD, Thin SVD and Truncated SVD

11.4.2 Decomposition into Rank One Matrices

I hope that you’ll find this content useful! Feel free to contact me if you have any question, request, or feedback!

## Benefits and challenges of data transformation

Transforming data yields several benefits:

• Data is transformed to make it better-organized. Transformed data may be easier for both humans and computers to use.
• Properly formatted and validated data improves data quality and protects applications from potential landmines such as null values, unexpected duplicates, incorrect indexing, and incompatible formats.
• Data transformation facilitates compatibility between applications, systems, and types of data. Data used for multiple purposes may need to be transformed in different ways..

However, there are challenges to transforming data effectively:

• Data transformation can be expensive. The cost is dependent on the specific infrastructure, software, and tools used to process data. Expenses may include those related to licensing, computing resources, and hiring necessary personnel.
• Data transformation processes can be resource-intensive. Performing transformations in an on-premises data warehouse after loading, or transforming data before feeding it into applications, can create a computational burden that slows down other operations. If you use a cloud-based data warehouse, you can do the transformations after loading because the platform can scale up to meet demand.
• Lack of expertise and carelessness can introduce problems during transformation. Data analysts without appropriate subject matter expertise are less likely to notice typos or incorrect data because they are less familiar with the range of accurate and permissible values. For example, someone working on medical data who is unfamiliar with relevant terms might fail to flag disease names that should be mapped to a singular value or notice misspellings.
• Enterprises can perform transformations that don’t suit their needs. A business might change information to a specific format for one application only to then revert the information back to its prior format for a different application.

## Desmos 2 – Transformations of Graphs

#### By Mark Dawes (January 2019)

If you are new to Desmos you might want to read my earlier blog Desmos – the basics first.

This blog will explore ways to use Desmos (www.desmos.com) to teach transformations of graphs at GCSE and at A-level mathematics. This isn’t a lesson plan but the ideas here could easily be used in lessons there are a number of different alternatives (such as using sliders, relating graphs to tables and using function notation) that may be appropriate for different classes or at different levels. I have written the things I suggest saying to the class in the form of instructions. There are alternatives that will work as well, so these are merely suggestions.

### Starting point: moving graphs up and down

I think this is well worth spending time on, even though it is something the pupils are likely to be familiar with already (from their work with y = mx+c), to enable new links to be made and to explore _why_ graphs move in the way they do.

Type in these two graphs. Ask pupils to describe how to turn the red graph into the blue one. Ensure they know that every point on the red graph has been moved up (vertically) by 2. This isn’t always clear: to some pupils the blue graph looks as if it has been made by squeezing the red graph inwards.

Ask what would happen to the blue graph if the blue equation became y = x 2 + 3, or y = x 2 – 1 or …. Each time, edit the blue equation and the pupils can see whether they are right.

Now delete the blue graph and click on the cog:

and select ‘convert to table’:

It will now look like this:

If you click on the part I have highlighted in yellow and then type x^2+2 you will see this:

To draw the blue curve, click again on the cog and then click on the blue dot in the table-heading and turn the ‘lines’ button on (highlighted):

Use this to show _why_ the curve has moved up by 2.

It is rather nice that there are now dots for the points in the table, so we can see more clearly that every point has moved upwards by 2.

Emphasise that for the red graph we calculated x-squared and plotted that against the x-value. For the blue graph we calculated x-squared but added 2 to it before plotting it against the x-value, so the y-co-ordinate of every point is bigger by 2 than it used to be and the graph has therefore moved upwards by 2.

### Using f(x)

This can be used as a way to point out some of the power of function notation. It could be used in addition to what has been done previously or instead of it.

I have illustrated this using the graph of f(x) = x 3 . As I mentioned in my previous post, one of the few things I dislike about Desmos is that it happily draws the graph of y = f(x) without being asked.

The next screenshot shows a very similar set of transformations, again linking the table of values to the graph (with the table of values being created as above).

All of the previous things (like changing the ‘+2’ at the end of the table-heading) can be done here too.

One of the brilliant things about this version is that if the original f(x) is changed (for example, to x 3 + 2x 2 , then everything else changes too, including the table and all of the graphs. This can be used to good effect to demonstrate that _all_ graphs move up by 2 when ‘+2’ is put on the end.

Using a slider

If you type y = x 2 + a Desmos asks whether you want to ‘add slider’. Just press enter and it happens automatically.

Click on the cog if you want to change the sensitivity of the slider.

This can be used to show the graph moving up and down as the value of ‘a’ changes. It also works well with the f(x) form of the algebra.

Potential misconception

Do beware that some students get used to the idea that “the number on the end” is the same as “the y-intercept”. For example, in y = mx + c, the ‘+c’ is indeed the y-intercept, and the same is true for y = ax 2 + bx + c and for any other polynomial. This is not always the case, though, and that is one reason for choosing to call the slider ‘a’ rather than ‘c’ in the section above. It would be useful to use some examples where the added number is not the y-intercept, such as y = 1/x + 1 (which doesn’t have a y-intercept at all) and y = 2 x + 1 and y = cos(x) + 1 (both of which have y-intercept of 2).

I have included this trig graph as a reminder of how to change Desmos to degrees and to change the scale. Click on the spanner on the right-hand side and change the values as shown:

### Moving graphs left and right

To many students it feels as if this version moves “the wrong way”. This next screenshot shows several ideas at the same time. (This can also be done with y = x 3 and y = (x+1) 3 .)

I like to start with something non-standard where there are no repeated values for f(x), to avoid confusion later on. Then get Desmos to create the table as before and draw the curve.

Draw students’ attention to the table. The same values crop up in both columns. Why are they shifted in the way they are? In the original graph, when x = 0 we plot the value of f(0). But in the version with f(x + 1), to get the same y-co-ordinate (which is f(0) in this case) we need x to be -1 and so we need to plot it one place to the left. In the table we can see every time that the values of f(x+1) now appear moved to the left by 1.

We can do many of the same things as we did before, like putting in a slider (perhaps having y = f(x + b) this time).

### Hiding the actual function

It can work very well to give students a function that they don’t recognise and to ask them to transform it using their transformation knowledge, without the risk that they will try to substitute or to expand brackets.

Before you start projecting it to the class, at the top of a Desmos file create an unfamiliar function, such as:

Press ‘enter’ a sufficient number of times so the function disappears off the top of the screen.

We can clearly see that the orange graph has been moved to the left by 2 and up by 1 to form the blue graph.

### Stretching vertically

I have started with f(x) and have drawn the table as well as the graph. For y = 3f(x) what used to be plotted as a y-co-ordinate has been multiplied by 3 before being plotted. This means that anything that had a y-value of zero before still has a y-value of zero, anything that was previously positive is 3 times the size and anything that was negative is still negative but has been multiplied by 3. Everything has been stretched in an up-down direction by a factor of 3: all the points are three times as far from the x-axis.

I have extended the table to include more values. This is easy to do: click in the x-column (originally the first value is -2 – click on that) and type what you want. If you press ‘enter’ it creates a new empty row for you to type into.

Potential misconception

I would be wary of starting with f(x) = x 2 here. That graph touches the x-axis only once and everywhere else it is above the x-axis. This can lead to the misconception that a stretch pulls the graph _upwards_ only.

Multiple sliders

We can combine all three of the transformations we have looked at so far using multiple sliders (just type the letters: Desmos will add the sliders for you). Do note that our students do not need to combine anything more complicated than these transformations.

This screenshot shows that it has been shifted left by 2, stretched up and down by a factor of 3.5 and then moved up by 2. (To consider: does the order matter? Sometimes …!)

### Squashing inwards

If we transform f(x) into f(2x) it again appears to some students that things happen the “wrong way around” because the graph is “squashed inwards” by a factor of 2.

That is because when we plot y = f(2x), what used to be plotted at x = 2 when we had y = f(x) is now plotted at x = 1. For y = f(2x) everything becomes half the distance from the y-axis that it was before.

### Understanding negatives

The final type of transformation we will look at is what happens if we have y = -f(x) or y = f(-x). Students often find these confusing, particularly because with certain functions (such as f(x) = sin(x) and f(x) = x 3 , known as ‘odd functions’) they look the same.

If we compare y = f(x) and y = -f(x) we know that in both cases we are working out f(x), but that in the second case, we don’t plot the value we work out but instead plot the negative version. Again, the table can show this and helps to explain why this gives a reflection in the x-axis.

If we compare y = f(x) and y = f(-x) we can see that what used to be plotted at a positive value of x is now plotted at the negative version of x (and vice-versa). This helps us to see that we are reflecting in the y-axis.

A final thought is that there is too much choice as to which graph to use to demonstrate or to discuss a particular transformation. Do consider carefully which one to use in a given situation. For example: -sin(x) = sin(-x), so that might not be helpful when demonstrating the negative transformations. cos(x) = cos (-x), so discussing reflection in the y-axis using this as a first example might not be helpful (the same is true for x 2 and (-x) 2 ).

Trig functions can be helpful for the multiplication transformations, however, given that 2sin(x) looks very different from sin(2x), but might not be as useful for the left-right translation because they are periodic.

## 1.6.4.7: Changing data- basics of transformations - Mathematics

Transformations play a very important role in manipulating objects on screen. It should be noted that here the algorithms will be implemented in code and the built-in functions will not be used to give a good understanding of how the algorithms work.
Also note that all transformations are implemented in 2D.
There are three basic kinds of Transformations in Computer Graphics:
1. Translation
2. Rotation
3. Scaling

1. Translation : Translation refers to moving an object to a different position on screen.
2. Rotation : Rotation refers to rotating a point.
3. Scaling : Scaling refers to zooming in and out an object in different scales across axes.

Note: If combined transformations is to be applied, follow the order: translate, rotate, scale

Our faculty and students explore new ideas in mathematics and its applications.

### Upcoming Events

Department of Mathematics
University of Washington

Box 354350
Seattle, WA 98195-4350
Phone: (206) 543-1150
Fax: (206) 543-0397

## DMCA Complaint

If you believe that content available by means of the Website (as defined in our Terms of Service) infringes one or more of your copyrights, please notify us by providing a written notice (“Infringement Notice”) containing the information described below to the designated agent listed below. If Varsity Tutors takes action in response to an Infringement Notice, it will make a good faith attempt to contact the party that made such content available by means of the most recent email address, if any, provided by such party to Varsity Tutors.

Your Infringement Notice may be forwarded to the party that made the content available or to third parties such as ChillingEffects.org.

Please be advised that you will be liable for damages (including costs and attorneys’ fees) if you materially misrepresent that a product or activity is infringing your copyrights. Thus, if you are not sure content located on or linked-to by the Website infringes your copyright, you should consider first contacting an attorney.

You must include the following:

Send your complaint to our designated agent at:

Charles Cohn Varsity Tutors LLC
101 S. Hanley Rd, Suite 300
St. Louis, MO 63105

## Lesson 7: Transformations & Interactions

In Lessons 4 and 6, we learned tools for detecting problems with a linear regression model. Once we've identified problems with the model, we have a number of options:

• If important predictor variables are omitted, see whether adding the omitted predictors improves the model.
• If the mean of the response is not a linear function of the predictors, try a different function. For example, polynomial regression involves transforming one or more predictor variables while remaining within the multiple linear regression framework. For another example, applying a logarithmic transformation to the response variable also allows for a nonlinear relationship between the response and the predictors while remaining within the multiple linear regression framework.
• If there are unequal error variances, try transforming the response and/or predictor variables or use "weighted least squares regression" (see Lesson 10).
• If an outlier exists, check if there is a data recording error, try a different model, collect more data if possible, or try using a "robust estimation procedure" (not considered in this course).
• If error terms are not independent, try fitting a "time series model" (see Lesson 10).

Transforming response and/or predictor variables therefore has the potential to remedy a number of model problems. Such data transformations are the focus of this lesson.

To introduce basic ideas behind data transformations we first consider a simple linear regression model in which:

• We transform the predictor (x) values only.
• We transform the response (y) values only.
• We transform both the predictor (x) values and response (y) values.

It is easy to understand how transformations work in the simple linear regression context because we can see everything in a scatterplot of y versus x. However, these basic ideas apply just as well to multiple linear regression models. With multiple predictors, we can no longer see everything in a single scatterplot, so now we use residual plots to guide us.

You will discover that data transformation definitely requires a "trial and error" approach. In building the model, we try a transformation and then check to see if the transformation eliminated the problems with the model. If it doesn't help, we try another transformation and so on. We continue this cyclical process until we've built a model that is appropriate and we can use. That is, the process of model building includes model formulation, model estimation, and model evaluation:

• Model building
• Model formulation
• Model estimation
• Model evaluation

We don't leave the model building process until we've convinced ourselves that the model meets the four conditions ("LINE") of the linear regression model. One important thing to remember is that there is often more than one viable model. The model you choose and the model a colleague chooses may be different and yet both equally appropriate. What's important is that the model you choose:

• is not overly complicated
• meets the four conditions of the linear regression model, and

Don't forget that data analysis is an artful science! It involves making subjective decisions using very objective tools!

## The Projection matrix

We’re now in Camera Space. This means that after all theses transformations, a vertex that happens to have x==0 and y==0 should be rendered at the center of the screen. But we can’t use only the x and y coordinates to determine where an object should be put on the screen : its distance to the camera (z) counts, too ! For two vertices with similar x and y coordinates, the vertex with the biggest z coordinate will be more on the center of the screen than the other.

This is called a perspective projection :

And luckily for us, a 4x4 matrix can represent this projection 1 :

We went from Camera Space (all vertices defined relatively to the camera) to Homogeneous Space (all vertices defined in a small cube. Everything inside the cube is onscreen).

Here’s another diagram so that you understand better what happens with this Projection stuff. Before projection, we’ve got our blue objects, in Camera Space, and the red shape represents the frustum of the camera : the part of the scene that the camera is actually able to see.

Multiplying everything by the Projection Matrix has the following effect :

In this image, the frustum is now a perfect cube (between -1 and 1 on all axes, it’s a little bit hard to see it), and all blue objects have been deformed in the same way. Thus, the objects that are near the camera ( = near the face of the cube that we can’t see) are big, the others are smaller. Seems like real life !

Let’s see what it looks like from the “behind” the frustum :

Here you get your image ! It’s just a little bit too square, so another mathematical transformation is applied (this one is automatic, you don’t have to do it yourself in the shader) to fit this to the actual window size :

## 1.6.4.7: Changing data- basics of transformations - Mathematics

In this section we are going to see how knowledge of some fairly simple graphs can help us graph some more complicated graphs. Collectively the methods we’re going to be looking at in this section are called transformations.

#### Vertical Shifts

The first transformation we’ll look at is a vertical shift.

Given the graph of (fleft( x ight)) the graph of (gleft( x ight) = fleft( x ight) + c) will be the graph of (fleft( x ight)) shifted up by (c) units if (c) is positive and or down by (c) units if (c) is negative.

So, if we can graph (fleft( x ight)) getting the graph of (gleft( x ight)) is fairly easy. Let’s take a look at a couple of examples.

The first thing to do here is graph the function without the constant which by this point should be fairly simple for you. Then shift accordingly.

In this case we first need to graph () (the dotted line on the graph below) and then pick this up and shift it upwards by 3. Coordinate wise this will mean adding 3 onto all the (y) coordinates of points on ().

Here is the sketch for this one.

Okay, in this case we’re going to be shifting the graph of (sqrt x ) (the dotted line on the graph below) down by 5. Again, from a coordinate standpoint this means that we subtract 5 from the (y) coordinates of points on (sqrt x ).

So, vertical shifts aren’t all that bad if we can graph the “base” function first. Note as well that if you’re not sure that you believe the graphs in the previous set of examples all you need to do is plug a couple values of (x) into the function and verify that they are in fact the correct graphs.

#### Horizontal Shifts

These are fairly simple as well although there is one bit where we need to be careful.

Given the graph of (fleft( x ight)) the graph of (gleft( x ight) = fleft( ight)) will be the graph of (fleft( x ight)) shifted left by (c) units if (c) is positive and or right by (c) units if (c) is negative.

Now, we need to be careful here. A positive (c) shifts a graph in the negative direction and a negative (c) shifts a graph in the positive direction. They are exactly opposite than vertical shifts and it’s easy to flip these around and shift incorrectly if we aren’t being careful.

Okay, with these we need to first identify the “base” function. That is the function that’s being shifted. In this case it looks like we are shifting (fleft( x ight) = ). We can then see that,

In this case (c = 2) and so we’re going to shift the graph of (fleft( x ight) = ) (the dotted line on the graph below) and move it 2 units to the left. This will mean subtracting 2 from the (x) coordinates of all the points on (fleft( x ight) = ).

Here is the graph for this problem.

In this case it looks like the base function is (sqrt x ) and it also looks like (c = - 4) and so we will be shifting the graph of (sqrt x ) (the dotted line on the graph below) to the right by 4 units. In terms of coordinates this will mean that we’re going to add 4 onto the (x) coordinate of all the points on (sqrt x ).

Here is the sketch for this function.

#### Vertical and Horizontal Shifts

Now we can also combine the two shifts we just got done looking at into a single problem. If we know the graph of (fleft( x ight)) the graph of (gleft( x ight) = fleft( ight) + k) will be the graph of (fleft( x ight)) shifted left or right by (c) units depending on the sign of (c) and up or down by (k) units depending on the sign of (k).

Let’s take a look at a couple of examples.

In this part it looks like the base function is () and it looks like will be shift this to the right by 2 (since (c = - 2)) and up by 4 (since (k = 4)). Here is the sketch of this function.

For this part we will be shifting (left| x ight|) to the left by 3 (since (c = 3)) and down 5 (since (k = - 5)). Here is the sketch of this function.

#### Reflections

The final set of transformations that we’re going to be looking at in this section aren’t shifts, but instead they are called reflections and there are two of them.

Given the graph of (fleft( x ight)) then the graph of (gleft( x ight) = - fleft( x ight)) is the graph of (fleft( x ight)) reflected about the (x)-axis. This means that the signs on the all the (y) coordinates are changed to the opposite sign.

Given the graph of (fleft( x ight)) then the graph of (gleft( x ight) = fleft( < - x> ight)) is the graph of (fleft( x ight)) reflected about the (y)-axis. This means that the signs on the all the (x) coordinates are changed to the opposite sign.

Here is an example of each.

Based on the placement of the minus sign (i.e. it’s outside the square and NOT inside the square, or ( ight)^2>) ) it looks like we will be reflecting () about the (x)-axis. So, again, the means that all we do is change the sign on all the (y) coordinates.

Here is the sketch of this graph.

Now with this one let’s first address the minus sign under the square root in more general terms. We know that we can’t take the square roots of negative numbers, however the presence of that minus sign doesn’t necessarily cause problems. We won’t be able to plug positive values of (x) into the function since that would give square roots of negative numbers. However, if (x) were negative, then the negative of a negative number is positive and that is okay. For instance,

[hleft( < - 4> ight) = sqrt < - left( < - 4> ight)> = sqrt 4 = 2]

So, don’t get all worried about that minus sign.

Now, let’s address the reflection here. Since the minus sign is under the square root as opposed to in front of it we are doing a reflection about the (y)-axis. This means that we’ll need to change all the signs of points on (sqrt x ).

Note as well that this syncs up with our discussion on this minus sign at the start of this part.

Here is the graph for this function.