More

7.4: Adding Arrows - Geosciences


This essay is largely based on Richard Feynman's book "QED - The Strange Behavior of Light and Matter" and his lectures in Auckland, New Zealand. The first being the written version of the many lectures held by Feynman at universities around the world in the 1970' and 1980's.

Quantum electrodynamics is a topic not very well understood by gemologists (or even by physic majors), but with the simple concept of "adding arrows" the strange behavior of light can, at least partially, be explained. Nobel Prize winner Richard Feynman had the ability to teach hardcore quantum theory at a novice level maybe only to be surpassed by Walter Lewin. Throughout everything Feynman freely admits that some things just can not be explained at present, nor that anything he lectured is correct. In 10 years we might have much more insight in the strange behavior of light, but at present we will have to do with empirical knowledge and our limited understanding.

The main objective of this essay is therefore not to be authoritative or correct, just to dive a little deeper in the topic of light so we may understand how light works. From why light doesn't travel in a straight line to how diffraction works, it can all be explained by the simple concept of "adding arrows".

Reflection

When a light source is pointed at a reflecting surface, we are taught that the reflection will reach a point on the opposite of the normal and that the angles of incidence and the angle of reflection are equal. The incident ray, the reflected ray and the normal all lie in the same plane. That is the "law of reflection". A logical interpretation of that might be that light will always follow that path of least distance (or even least time). That raises a few questions, as how much of the light will be reflected from the glass plate. Or if we would paint a portion of the glass black, would it still be able to reflect light from light source A to detector point B? According to the usual law of reflection, the latter should not occur. In reality, it could reflect more.

Figure (PageIndex{1}): Possible paths light can take when traveling from point A to point B via a reflecting surface

For us to understand this, we need to let go of the idea that light travels only in a straight line from A to B or that there is only one path a light ray can take to get from A to B, via a reflecting surface, when the shortest path between A and B is blocked.

When a photon travels from point A to point B via a reflecting surface, it can take an infinite amount of paths to reach B. The shortest possible route being dictated by the law of reflection (depicted as the green arrows). However there is no reason why the photon could not take a longer path, and in fact, it does. It could easily follow the red paths (which are longer paths) or the blue paths (even longer) or anything in between. If we were to place a detector at point B and measure the time it takes to get from point A to B via the reflecting glass, the time for every photon to arrive at point B will be different. A good indicator that light does not always travel the shortest distance.

If we were to take a stopwatch with counter-clockwise rotating hand, the hand would stop at a different "hour" for each of these paths and we can think of the direction the hand is pointing to as an "arrow" (as indicated at the bottom of the image).
The lengths of the arrows are arbitrary and the same for every stopwatch.
The arrows are known by physicists as "phasors" and the direction in which they point is referred to as the "phase angle".

Figure (PageIndex{2}): Close up of reflection on different spots of a mirror with arrows and the adding of arrows

We could divide the reflecting surface into small portions (an infinite amount) and calculate the time it takes for a photon to get from source S to a detector P (P for photomultiplier). The stopwatch (with a very fast rotating hand) is started when the photon is emitted at S and stopped when it is detected at P.
Although the mirror can be divided into an infinite amount of small sections, for simplicity only 11 are drawn (from A through K). The small arrows below the sections represent the directions that the stopwatch hand is pointing at when the experiment is done.

We then start "adding the arrows", starting with arrow A. We do that by placing arrow B with its tail on the head of arrow A (without changing the direction of the arrow). Arrow C will be placed with its tail on the head of arrow B and so forth until we get a snake-like figure of arrows.
We then draw a final arrow that starts at the tail of A and ends at the head of arrow K (seen as the red arrow). This final arrow is the amplitude of all the photons that are reflected from the mirror.
As can be seen in the image, the sections E, F and G contribute the most to the final arrow. While the reflection in the outer regions of the mirror tend to detract from the final arrow. This means that the amount of reflection of a mirror is largely due to reflections around the centerpoint (F), and not of the centerpoint alone as we learned in the classical view of reflection.

As can be seen from the arrows, the sections A and B are causing the final arrow to be shorter and in fact interfere with the final amount of reflection. One could ask oneself, what would happen when we could get rid of one of those interfering arrows. One way of doing that is by making that section not reflect, for instance by painting it with a non-reflecting paint.

Diffraction

Figure (PageIndex{3}): Removing a reflection section can add to the total reflection

When we take away the reflection of a particular section, we also take away the arrow (as there is no reason to time the reflection on a non-reflecting surface). This means that the adding of the arrows will now change. As we removed the arrow that belonged to section B, we now must place the arrow from C on the arrow of A.
This results in a longer final arrow (from A to K) as seen in the image as a blue arrow (the original red arrow is left in to show the difference). This means that by removing a specific section of the mirror (by making that part non-reflecting), the total reflection of the mirror can be increased. Strange but true.

As always, there is no such thing as a free lunch and there is a catch. The removed section needs to be very small, a strip of about 1/1000th of a millimeter, and a sequence of those small strips will only reflect monochromatic light.
An added, and not anticipated, bonus is that if you move the detector, it will reflect another color of the visible spectrum. Thus that part of the mirror is now working as a diffraction grating.

Figure (PageIndex{4}): Interference of arrows after adding

A close up of section A, B and C (the outer perimeters of the mirror) shows that many photos of light hit a specific area. One can draw in as many as one likes. All of them will need a different time to get to the detector and thus all will have a specific arrow associated with them. The area A to C shows arrows that interfere with each other, in effect canceling each other out and that region will therefore not contribute to the final amount of reflection of the whole mirror. When the arrows of that region are added (heads to tails) they form a circle or a spiral of arrows.

When one would make the areas that are detracting from the total reflection, i.e. the arrows who are pointing in the "wrong" way, non-reflecting then the overall reflectivity of the mirror will increase.

Figure (PageIndex{5}): Increased reflectivity after adding of the arrows, diffraction

One could make the areas where the arrows are pointing the wrong way black to make it non-reflective or one could etch away areas where the arrows are pointing in the desired direction. When one does either of the two, a diffraction grating is created.

Of course, the spaces between the reflecting and non-reflecting parts (named "grooves" in a diffraction grating material) are very closely spaced.

As mentioned earlier, the reflection on the grooves only works for monochromatic light, like red light, because the stopwatch for blue light spins faster than for red light (so the arrows would point in a different direction for blue light). However if one would move the detector, it works again for blue light (but not for red light).
If our eye is the detector, then it could work for both blue and red light (and everything in between) because our eye has a wide view and acts like many detectors at different places.


Create an assignment in Microsoft Teams

Note: The Assignments tab is only available in class teams. You can assign assignments to classes of up to 300 students.

Create a new assignment

Navigate to the General channel in the desired classroom, then select Assignments.

Select Create>Assignment.

Note: Select Expand tab (diagonal, double sided arrow) to enter full-screen mode.

Enter a title for this assignment—this is required.

Provide more information for the assignment.

The following steps are optional:

Choose who should receive the assignment

Choose multiple classes or individual students in one class to assign to.

Decide if students who join this class in the future should receive this assignment. By default, only students who are in your class now will receive it.


To do this, select Edit next to Don't assign students added to this class in the future. Make your selection, and then select Done.

Note: If you choose a close date, any student who joins will receive this assignment until the close date.

Add additional instructions

Click the instructions box to add instructions and edit them in rich text.

Add resources or a new file

Add existing files, links, or assignment integrations to your assignment. You can also create and name a new file right from here for students to turn in.

Attach resources to the assignment by selecting Add resources.

Choose a file from your OneDrive, upload a file from your device, or choose one of the other options, such as MakeCode.

Select +New to create a blank Word (.docx), Excel (.xlsx), or PowerPoint (.pptx) document to hand out to your students.

The default for the resource or new file you add will be Students can't edit, which means the document is read-only. This is a great option for reference materials.

Select More options > Students edit their own copy if you'd like each student to edit their own document and turn it in for a grade.

You can add up to five files for students to edit. The total number of resources you can add to an assignment is 10, whether editable or non-editable. Read-only reference files can be up to 500 MB in size. Files for students to edit can be up to 50 MB in size.

If you're assigning a Class Notebook page, check to see what version of OneNote your students are using to ensure that their assignment pages will lock after the assignment due date passes.

If you have older documents with the file extension .doc, .xls, or .ppt, students won't be able to edit them. You can either attach them as read-only reference material or create a new file in Teams. Copy in the old content and save. Your new file will have the updated .docx, .xlsx, and .pptx file extension. All new files you create in Teams or other Office 365 apps will have the correct extension.

Select due date and time

For more assignment timeline options, select Edit.

Here, you can customize when your assignment will be posted to students and when it will close for turn-ins. By default, no close date will be selected, which allows students to turn in assignments late.

Points, rubrics, and grading

Select the amount of points this assignment is worth, if any. You can use points on any number-based scale including whole numbers of 100 and set your own denominator.

Examples: 88/100 or decimals 3.7/4.0.

Select Add rubric to add a grading rubric.

Add assignment to calendars

You can choose whether to add this assignment to your calendar, students' calendars, and other educators or staff in your class team. Set this preference for all assignments in Assignments Settings.

Select the dropdown next to Add assignment to calendars.

Choose Students and me to add it for the students receiving the assignment and you.

Choose Students and team owners to add it for students and other educators or staff in the class team.

Note: To check on your full class team roster, navigate to your class team and select More options >Manage team.

When you select Assign, the new assignment will appear on calendars in Teams and Outlook. Double-click or tap the calendar entry to view the assignment.

Choose where assignment notifications should post

Choose the channel where you'd like notifications for this assignment to post. This allows you to keep student work and discussion organized by unit, topic, or subject.

To choose a channel to post in, select Edit next to Post assignment notifications to this channel. Assignments will default to posting in the General channel or your selection in Assignments Settings.

Choose the channel you’d like this assignment notification to post in, then Done.

To post assignment notifications to a channel, make sure bot posting is enabled. You can check that here or ask your IT Admin for help.

Assignments will post to channels that are visible to all students. Private channels will not appear during this step.

Assignments to multiple classes can only post to the General channel. Assignments to individual students do not post to channels.

Send assignment to students

When you're ready, finish the process of creating your new assignment.

Select Assign. Your students will be notified of the new assignment on the day you specified and the notification linking to this assignment will post in the channel you selected. They'll also have an entry on their Teams and Outlooks calendars if you've selected that option.

Select Discard to discontinue work on this assignment or Save to return to the assignment and edit it later.


First lets download PHP 7.4 for Windows. Here is a direct link for 64 bits and 32 bits. Extract the downloaded zip file to Laragon’s PHP folder.

Note that Laragon’s PHP folder can be found on this path:

Now open Laragon app on your system, click on Menu, navigate to the menu item, then change the PHP version to the latest one you have on your system.

Now you have your local development environment running PHP 7.4!


7.4: Adding Arrows - Geosciences

Class properties now support type declarations.

Arrow functions

Arrow functions provide a shorthand syntax for defining functions with implicit by-value scope binding.

Limited return type covariance and argument type contravariance

The following code will now work:

<?php
class A <>
class B extends A <>

class Producer <
public function method (): A <>
>
class ChildProducer extends Producer <
public function method (): B <>
>
?>

Null coalescing assignment operator

Unpacking inside arrays

Numeric literal separator

Numeric literals can contain underscores between digits.

Weak references

Weak references allow the programmer to retain a reference to an object that does not prevent the object from being destroyed.

Allow exceptions from __toString()

Throwing exceptions from __toString() is now permitted. Previously this resulted in a fatal error. Existing recoverable fatal errors in string conversions have been converted to Error exceptions.

CURLFile now supports stream wrappers in addition to plain file names, if the extension has been built against libcurl >= 7.56.0.

Filter

The FILTER_VALIDATE_FLOAT filter now supports the min_range and max_range options, with the same semantics as FILTER_VALIDATE_INT .

FFI is a new extension, which provides a simple way to call native functions, access native variables, and create/access data structures defined in C libraries.

Added the IMG_FILTER_SCATTER image filter to apply a scatter filter to images.

Added crc32c hash using Castagnoli's polynomial. This CRC32 variant is used by storage systems, such as iSCSI, SCTP, Btrfs and ext4.

Multibyte String

Added the mb_str_split() function, which provides the same functionality as str_split() , but operating on code points rather than bytes.

OPcache

Regular Expressions (Perl-Compatible)

The preg_replace_callback() and preg_replace_callback_array() functions now accept an additional flags argument, with support for the PREG_OFFSET_CAPTURE and PREG_UNMATCHED_AS_NULL flags. This influences the format of the matches array passed to the callback function.

The username and password can now be specified as part of the PDO DSN for the mysql, mssql, sybase, dblib, firebird and oci drivers. Previously this was only supported by the pgsql driver. If a username/password is specified both in the constructor and the DSN, the constructor takes precedence.

It is now possible to escape question marks in SQL queries to avoid them being interpreted as parameter placeholders. Writing ?? allows sending a single question mark to the database and e.g. use the PostgreSQL JSON key exists ( ? ) operator.

PDO_OCI

PDO_SQLite

PDOStatement::getAttribute(PDO::SQLITE_ATTR_READONLY_STATEMENT) allows checking whether the statement is read-only, i.e. if it doesn't modify the database.

PDO::setAttribute(PDO::SQLITE_ATTR_EXTENDED_RESULT_CODES, true) enables the use of SQLite3 extended result codes in PDO::errorInfo() and PDOStatement::errorInfo() .

SQLite3

Added SQLite3::lastExtendedErrorCode() to fetch the last extended result code.

Added SQLite3::enableExtendedResultCodes($enable = true) , which will make SQLite3::lastErrorCode() return extended result codes.

Standard

Strip_tags() with array of tag names

strip_tags() now also accepts an array of allowed tags: instead of strip_tags($str, '<a><p>') you can now write strip_tags($str, ['a', 'p']) .

Custom object serialization

A new mechanism for custom object serialization has been added, which uses two new magic methods: __serialize and __unserialize .

<?php
// Returns array containing all the necessary state of the object.
public function __serialize (): array

// Restores the object state from the given data array.
public function __unserialize (array $data ): void
?>

Array merge functions without arguments

array_merge() and array_merge_recursive() may now be called without any arguments, in which case they will return an empty array. This is useful in conjunction with the spread operator, e.g. array_merge(. $arrays) .

Proc_open() function

proc_open() now accepts an array instead of a string for the command. In this case the process will be opened directly (without going through a shell) and PHP will take care of any necessary argument escaping.

proc_open() now supports redirect and null descriptors.

Argon2i(d) without libargon

password_hash() now has the argon2i and argon2id implementations from the sodium extension when PHP is built without libargon.

User Contributed Notes 2 notes

It should be noted that typed properties internally are never initialized to a default null. Unless of course you initialize them to null yourself. That's why you will always going to encounter this error if you try to access them before initialization.

**Typed property foo::$bar must not be accessed before initialization**

<?php
class User
<
public $id
public string $name // Typed property (Uninitialized)
public ? string $age = null // Typed property (Initialized)
>

$user = new User
var_dump ( is_null ( $user -> id )) // bool(true)
var_dump ( is_null ( $user -> name )) // PHP Fatal error: Typed property User::$name must not be accessed before initialization
var_dump ( is_null ( $user -> age )) // bool(true)
?>

Another thing worth noting is that it's not possible to initialize a property of type object to anything other than null. Since the evaluation of properties happens at compile-time and object instantiation happens at runtime. One last thing, callable type is not supported due to its context-dependent behavior.

// How to get property type? For example for testing:

class Foo
<
private int $num
private bool $isPositive
private $notes
>

$reflection = new ReflectionClass ( Foo ::class)
$classProperties = $reflection -> getProperties ( ReflectionProperty :: IS_PRIVATE )
foreach ( $classProperties as $classProperty ) <
var_dump ((string) $classProperty -> getType ())
>


Future Scope

These are some possible future extensions, but we don't necessarily endorse them.

Multi-statement bodies

An advantage of supporting this syntax is that it is possible to use a single closure syntax for all purposes (excluding cases that need to control binding behavior), rather than having to mix two different syntaxes depending on whether they use a single expression or multiple statements.

Switching the binding mode

Arrow functions use by-value binding by default, but could be extended with the possibility to capture variables by reference instead. This is particularly useful in conjunction with the previous section, as multi-statement bodies are more likely to be interested in modifying variables from the outer scope. A possible syntax would be:

Another possibility would be to keep by-value binding as the default, but allow using some explicitly specified variables by reference:

In this example $b is still implicitly used by-value, but $a is explicitly used by-reference. However, this syntax may be confusing as it is very close to the normal closure syntax, which would not implicitly bind $b .

Allow arrow notation for real functions

It would be possible to allow using the arrow notation for normal functions and methods as well. This would reduce the boilerplate for single-expression functions like getters:


Content editing tools

The new markup tools is available to everyone by 19 August 2021.

When files or a blank whiteboard are shared in a session, you can use annotation tools to edit and mark up the document during the live session. You’ll find the annotation tools at the top of the screen. These tools are available for both the moderator and participant roles unless the moderator turns it off in Session Settings .

Moderators can share an annotated file in the main room with breakout groups. More on sharing files with breakout groups.

Document view settings

  • Pan : Move the whiteboard or shared file on the page.
  • Zoom and Fit : Zoom in and out of the page or adjust the view to fit the page or width.

Annotations

  • Drawing , Brush , and Eraser : Draw freehand on the page with various colors, thickness, and opacity. Select the eraser to remove annotations. You can erase parts of a freehand drawing with the eraser or select the Delete icon to delete the whole drawing.
  • Text : Add text directly on the page. You can move, edit, and change the text and select the font, size, alignment, and color of the text.
  • Shapes : Choose Line , Arrow , Rectangle , Ellipse , Polygon , and Polyline . Each shape has its own settings to change the color, width, opacity, and more.
  • Clear Annotations : Annotations are saved in the session. You can share something new, go to a new slide, or stop sharing. The annotations remain. Moderators can use Clear Annotations to delete all annotations from all pages.
  • Highlighter : Select areas on a shared file to highlight. As you highlight text on the page, an additional menu opens. You can highlight, strikethrough, underline, squiggle, or comment on the highlighted section. The highlighter is only available on shared files. It's not available on the whiteboard.

Upload a blank file of several pages to have a multi-page whiteboard.


7.4: Adding Arrows - Geosciences

Arrow functions were introduced in PHP 7.4 as a more concise syntax for anonymous functions.

Arrow functions have the basic form fn (argument_list) => expr .

Arrow functions support the same features as anonymous functions, except that using variables from the parent scope is always automatic.

When a variable used in the expression is defined in the parent scope it will be implicitly captured by-value. In the following example, the functions $fn1 and $fn2 behave the same way.

Example #1 Arrow functions capture variables by value automatically

$fn1 = fn ( $x ) => $x + $y
// equivalent to using $y by value:
$fn2 = function ( $x ) use ( $y ) <
return $x + $y
>

The above example will output:

This also works if the arrow functions are nested:

Example #2 Arrow functions capture variables by value automatically, even when nested

$z = 1
$fn = fn ( $x ) => fn ( $y ) => $x * $y + $z
// Outputs 51
var_export ( $fn ( 5 )( 10 ))
?>

Similarly to anonymous functions, the arrow function syntax allows arbitrary function signatures, including parameter and return types, default values, variadics, as well as by-reference passing and returning. All of the following are valid examples of arrow functions:

Example #3 Examples of arrow functions

fn (array $x ) => $x
static fn (): int => $x
fn ( $x = 42 ) => $x
fn (& $x ) => $x
fn &( $x ) => $x
fn ( $x , . $rest ) => $rest

Arrow functions use by-value variable binding. This is roughly equivalent to performing a use($x) for every variable $x used inside the arrow function. A by-value binding means that it is not possible to modify any values from the outer scope. Anonymous functions can be used instead for by-ref bindings.

Example #4 Values from the outer scope cannot be modified by arrow functions

$x = 1
$fn = fn () => $x ++ // Has no effect
$fn ()
var_export ( $x ) // Outputs 1

Changelog

Version Description
7.4.0 Arrow functions became available.

Notes

Note: It is possible to use func_num_args() , func_get_arg() , and func_get_args() from within an arrow function.

User Contributed Notes 5 notes

In example 4 (Values from the outer scope cannot be modified by arrow functions)

$x = 1
$fn = fn () => $x ++ // Has no effect
$fn ()
var_export ( $x ) // Outputs 1

?>

Here we can use reference variable in fn(&$x) and pass the value from function call $fn($x) so that we will get the output as expected with out using Anonymous functions.

$x = 1
$fn = fn (& $x ) => $x ++
$fn ( $x )
var_export ( $x )

But here it will not take values from parent scope automatically but we have to pass them explicitly.

Unlike anonymous functions, arrow functions cannot have a void return type declaration.

May seem obvious, but if you thought you could make use of the benefits of arrow functions (using variables from the parent scope) to simplify a function or method call, keep in mind that this is only possible if you do NOT tell PHP that the arrow function does indeed return void.

Beware compact() not being able to access (import) variables from external scope (known in versions: 7.4.0, 7.4.8) (bug: https://bugs.php.net/bug.php?id=78970).

A workaround is available - use the variable directly this will cause it to be imported into the arrow function's namespace and make it available to the compact() too.

<?php
$aa = 111
$accessing_variable_works = fn ( $bb ) => [ $aa , $bb ]
$compact_is_broken = fn ( $bb ) => compact ( 'aa' , 'bb' )
$compact_can_work_with_workaround = fn ( $bb ) => compact ( 'aa' , 'bb' ) + [ 'workaround' => $aa ]
var_dump ( $accessing_variable_works ( 333 ))
var_dump ( $compact_is_broken ( 555 ))
var_dump ( $compact_can_work_with_workaround ( 777 ))
?>

result:
array(2) <
[0]=>
int(111)
[1]=>
int(333)
>
PHP Notice: compact(): Undefined variable: aa in /home/m/vlt/guitar/tlb/s/public_html/index.php on line 9
array(1) <
["bb"]=>
int(555)
>
array(3) <
["aa"]=>
int(111)
["bb"]=>
int(777)
["workaround"]=>
int(111)
>

As you already know, variable bindings occur in arrow functions by "by-value". That means, an arrow function returns a copy of the value of the variable used in it from the outer scope.

Now let us see an example of how a arrow function returns a reference instead of a copy of a value.


Working with Input

Node.js provides a few ways to handle interactions, including the built-in process object and readline module. While these are powerful tools, they rely on callback functions and can be confusing to work with at first.

Running this code in Node, you’d see:

Then you could enter your input based on the prompt and see the response:

This works as intended, but it’s a lot of boilerplate, and you need to call readline.question() and create a callback function every time you want to use it for input. There’s a simpler way, whether you’re just getting started out with JavaScript development or just want to get an interactive script running as quickly as possible.


Author information

Affiliations

Department of Earth Sciences, University of Toronto, Toronto, Canada

Erkan Gün & Russell N. Pysklywec

Eurasia Institute of Earth Sciences, Istanbul Technical University, Istanbul, Turkey

Oğuz H. Göğüş & Gültekin Topuz

You can also search for this author in PubMed Google Scholar

You can also search for this author in PubMed Google Scholar

You can also search for this author in PubMed Google Scholar

You can also search for this author in PubMed Google Scholar

Contributions

E.G. designed and carried out the numerical experiments and interpreted the results with R.N.P. O.H.G. and G.T. helped with the geological background of the Alpine–Mediterranean region. E.G. and R.N.P. developed ‘the subduction pulley’ hypothesis and wrote the manuscript with inputs and comments from all the authors.

Corresponding author


Acknowledgments

[63] We are indebted to N. Snavely, Y. Furuoka, J. Ponce, C. Wu and J. Harle for freely providing the code that this work is based on. We thank J. P. Muller for provision of the Gotcha stereo matching engine, I. Marshall for use of the Riegl laser scanner, H. Tuffen for the loan of the Montserrat sample, B. van Wyk de Vries for the Piton de la Fournaise image set and control data, and N. Chappell for fruitful discussions on variogram analysis. Data from the Hazelrigg weather station were collected and made available by B. Davison. Point cloud ASCII to binary file format conversions were carried out using MeshLab (http://meshlab.sourceforge.net/), a tool developed with the support of the 3D-CoForm project. Tidal data were supplied by the British Oceanograpic Data Centre as part of the National Tidal and Sea Level Facility, hosted by the National Oceanography Centre, Liverpool, and funded by the Environment Agency and the Natural Environment Research Council. We are grateful to R. A. Thompson, W. T. Pfeffer, J. J. Major and one anonymous reviewer for detailed and constructive reviews.

Auxiliary material for this article contains details of the principal distance values that are recovered for the images used in the case study reconstructions.

Auxiliary material files may require downloading to a local drive depending on platform, browser, configuration, and size. To open auxiliary materials in a browser, click on the label. To download, Right-click and select “Save Target As…” (PC) or CTRL-click and select “Download Link to Disk” (Mac).

Additional file information is provided in the readme.txt.

Filename Description
jgrf952-sup-0001-readme.txtplain text document, 5 KB readme.txt
jgrf952-sup-0002-fs01.jpgJPEG image, 1.5 MB Figure S1. Recovered principal distances for the sample-scale case study.
jgrf952-sup-0003-fs02.jpgJPEG image, 1.5 MB Figure S2. Recovered principal distances for the hill-slope scale case study.
jgrf952-sup-0004-fs03.jpgJPEG image, 1.5 MB Figure S3. Recovered principal distances at the site-scale.
jgrf952-sup-0005-t01.txtplain text document, 971 B Tab-delimited Table 1.
jgrf952-sup-0006-t02.txtplain text document, 842 B Tab-delimited Table 2.

Please note: The publisher is not responsible for the content or functionality of any supporting information supplied by the authors. Any queries (other than missing content) should be directed to the corresponding author for the article.


How do we solve something with two inequalities at once?

Example:

First, let us clear out the "/3" by multiplying each part by 3.

Because we are multiplying by a positive number, the inequalities don't change:

Now subtract 6 from each part:

Now divide each part by 2 (a positive number, so again the inequalities don't change):

Now multiply each part by −1. Because we are multiplying by a negative number, the inequalities change direction.

But to be neat it is better to have the smaller number on the left, larger on the right. So let us swap them over (and make sure the inequalities point correctly):