Error incompatible types possible lossy conversion from double to float

Java: incompatible types, possible lossy conversion from double to float [duplicate]

why do I get this error message when i try to compile the following code?

incompatible types: possible lossy conversion from double to float

Am i getting an overflow? I’m looking to understand the theory behind this. Thanks in advance.

2 Answers 2

Use float literals:

0.1 and 0.002 are double literals. Java’s double type has more precision than its float type. So, when you convert from double to float , the number may be changed by rounding it to the nearest value representable in float . Using decimal as an analogy, assigning the four-digit .1234 to a two-digit type would produce a different number, .12.

When you do this conversion implicitly, by assignment to a float variable, the compiler tells you there could be a loss of information. By using a cast, you tell the compiler the conversion to a less precise format is intentional. Or by using float literals such as 0.1f and 0.002f , you work with float values throughout and avoid conversion.

Generally, pick one type, float or double and use it throughout your calculations, for both literals and variables.

Linked

Hot Network Questions

Site design / logo © 2023 Stack Exchange Inc; user contributions licensed under CC BY-SA . rev 2023.1.14.43159

By clicking “Accept all cookies”, you agree Stack Exchange can store cookies on your device and disclose information in accordance with our Cookie Policy.

Источник

What does «possible lossy conversion» mean and how do I fix it?

New Java programmers are often confused by compilation error messages like:

«incompatible types: possible lossy conversion from double to int»

for this line of code:

In general, what does the «possible lossy conversion» error message mean, and how do you fix it?

1 Answer 1

First of all, this is a compilation error. If you ever see it in an exception message at runtime, it is because you have have run a program with compilation errors 1 .

The general form of the message is this:

«incompatible types: possible lossy conversion from to «

where and are both primitive numeric types; i.e. one of byte , char , short , int , long , float or double .

This error happens when your code attempts to do an implicit conversion from to but the conversion could be lossy.

In the example in the question:

the sqrt method produces a double , but a conversion from double to int is potentially lossy.

What does «potentially lossy» mean?

Well lets look at a couple of examples.

A conversion of a long to an int is a potentially lossy conversion because there are long values that do not have a corresponding int value. For example, any long value that is greater than 2^31 — 1 is too large to be represented as an int . Similarly, any number less than -2^31 is too small.

A conversion of an int to a long is NOT lossy conversion because every int value has a corresponding long value.

A conversion of a float to an long is a potentially lossy conversion because there float values that are outside of the range that can be represented as long values. Such numbers are (lossily) convert into Long.MAX_VALUE or Long.MIN_VALUE , as are NaN and Inf values.

A conversion of an long to a float is NOT lossy conversion because every long value has a corresponding float value. (The converted value may be less precise, but «lossiness» doesn’t mean that . in this context.)

These are all the conversions that are potentially lossy:

• short to byte or char
• char to byte or short
• int to byte , short or char
• long to byte , short , char or int
• float to byte , short , char , int or long
• double to byte , short , char , int , long or float .

How do you fix the error?

The way to make the compilation error go away is to add a typecast. For example;

But is that really a fix? Consider that the square root of 47 is 6.8556546004 . but squareRoot will get the value 6 . (The conversion will truncate, not round.)

And what about this?

That results in b getting the value 0 . Converting from a larger int type to a smaller int type is done by masking out the high order bits, and the low-order 8 bits of 512 are all zero.

In short, you should not simply add a typecast, because it might not do the correct thing for your application.

Instead, you need to understand why your code needs to do a conversion:

• Is this happening because you have made some other mistake in your code?
• Should the be a different type, so that a lossy conversion isn’t needed here?
• If a conversion is necessary, is the silent lossy conversion that the typecast will do the correct behavior?
• Or should your code be doing some range checks and dealing with incorrect / unexpected values by throwing an exception?

«Possible lossy conversion» when subscripting.

The problem here is that array index value must be int . So d has to be converted from double to int . In general, using a floating point value as an index doesn’t make sense. Either someone is under the impression that Java arrays work like (say) Python dictionaries, or they have overlooked the fact that floating-point arithmetic is often inexact.

The solution is to rewrite the code to avoid using a floating point value as an array index. (Adding a type cast is probably an incorrect solution.)

This is a variation of the previous problem, and the solution is the same. The difference is that the root cause is that Java arrays are limited to 32 bit indexes. If you want an «array like» data structure which has more than 2 31 — 1 elements, you need to define or find a class to do it.

«Possible lossy conversion» in method or constructor calls

Compiling the above with Java 11 gives the following:

The problem is that the literal 20 is an int , and the corresponding parameter in the constructor is declared as a short . Converting an int to a short is lossy.

«Possible lossy conversion» in a return statement.

A return (with a value / expression) could be thought of an an «assignment to the return value». But no matter how you think about it, it is necessary to convert the value supplied to the actual return type of the method. Possible solutions are adding a typecast (which says «I acknowledge the lossy-ness») or changing the method’s return type.

This will tell you that you that there is a «possible lossy conversion from int to byte». This is actually a variation of the first example. The potentially confusing thing is understanding where the int comes from.

The answer to that is it comes from the & operator. In fact all of the arithmetic and bitwise operators for integer types will produce an int or long , depending on the operands. So in the above example, b1 & mask is actually producing an int , but we are trying to assign that to a byte .

To fix this example we must type-cast the expression result back to a byte before assigning it.

«Possible lossy conversion» when assigning literals

What is going on? Why is one version allowed but the other one isn’t? (After all they «do» the same thing!)

First of all, the JLS states that 21 is an numeric literal whose type is int . (There are no byte or short literals.) So in both cases we are assigning an int to a byte .

In the first case, the reason for the error is that not all int values will fit into a byte .

In the second case, the compiler knows that 21 is a value that will always fit into a byte .

The technical explanation is that in an assignment context, it is permissible to perform a primitive narrowing conversion to a byte , char or short if the following are all true:

• The value is the result of a compile time constant expression (which includes literals).
• The type of the expression is byte , short , char or int .
• The constant value being assigned is representable (without loss) in the domain of the «target» type.

Note that this only applies with assignment statements, or more technically in assignment contexts. Thus:

gives a compilation error.

1 — For instance, the Eclipse IDE has an option which allows you to ignore compilation errors and run the code anyway. If you select this, the IDE’s compiler will create a .class file where the method with the error will throw an unchecked exception if it is called. The exception message will mention the compilation error message.

Источник

Possible lossy conversion from double to float, given float values? [duplicate]

if i’m not mistaken, «0.5» are decimal numbers; thus, making it a float value. but why is java telling me that it is a double?. the return statements are detected as errors by java, saying: «incompatible types:possible lossy conversion from double to float»

4 Answers 4

If I’m not mistaken, 0.5 are decimal numbers; thus, making it a float value.

You should not rely solely on your intuition when learning a new programming language.

In fact, 0.5 is a double literal. For a float literal you need to write 0.5f .

As The Java Language Specification (JLS 3.10.2) states:

A floating-point literal is of type float if it is suffixed with an ASCII letter F or f ; otherwise its type is double and it can optionally be suffixed with an ASCII letter D or d .

You have two options.

One is change your method’s return type to double.

The other is change the double values you are returning to float values, as many have said in the comments.

In java, we have float and double as floating point literals, where double is the default data type of floating point literals and not the float. This is the reason why java is telling you that 0.5 is a double.

Possible conversion:

1) float a = (float) 0.5;

And reason for lossy conversion is because, double is bigger than float. When you try to fit-in the bigger one into the smaller one, you will get this error.

Источник

getting error: incompatible types: possible lossy conversion from double to float for type promotion code

i didnt understand the error when executing below code.

Main.java:7: error: incompatible types: possible lossy conversion from double to float float f = 9.987; ^ Main.java:9: error: incompatible types: possible lossy conversion from double to int int res = (fb) + (i/c) — (ds); ^ 2 errors

2 Answers 2

I guess you are beginner in java . So the mistake you are making is typecasting . You can not assign double value to a float type .

If you don’t want to face this problem again in future learn about type casting (automatic conversion and explicit conversion).

The result of an operation between different data types will always be the largest type (here double). If you want to keep the result as an int : look into casting values.

It should look like this : int res = (int) ((f*b) + (i/c) — (d*s))

Otherwise, make the result a double.

Also, floats in java need to have f at the end : float f = 9.987f;

Linked

Hot Network Questions

To subscribe to this RSS feed, copy and paste this URL into your RSS reader.

Site design / logo © 2023 Stack Exchange Inc; user contributions licensed under CC BY-SA . rev 2023.1.14.43159

By clicking “Accept all cookies”, you agree Stack Exchange can store cookies on your device and disclose information in accordance with our Cookie Policy.

Источник

How to Handle the Incompatible Types Error in Java

Table of Contents

Introduction to Data Types & Type Conversion

Variables are memory containers used to store information. In Java, every variable has a data type and stores a value of that type. Data types, or types for short, are divided into two categories: primitive and non-primitive. There are eight primitive types in Java: byte , short , int , long , float , double , boolean and char . These built-in types describe variables that store single values of a predefined format and size. Non-primitive types, also known as reference types, hold references to objects stored somewhere in memory. The number of reference types is unlimited, as they are user-defined. A few reference types are already baked into the language and include String , as well as wrapper classes for all primitive types, like Integer for int and Boolean for boolean . All reference types are subclasses of java.lang.Object [1].

In programming, it is commonplace to convert certain data types to others in order to allow for the storing, processing, and exchanging of data between different modules, components, libraries, APIs, etc. Java is a statically typed language, and as such has certain rules and constraints in regard to working with types. While it is possible to convert to and from certain types with relative ease, like converting a char to an int and vice versa with type casting [2], it is not very straightforward to convert between other types, such as between certain primitive and reference types, like converting a String to an int , or one user-defined type to another. In fact, many of these cases would be indicative of a logical error and require careful consideration as to what is being converted and how, or whether the conversion is warranted in the first place. Aside from type casting, another common mechanism for performing type conversion is parsing [3], and Java has some predefined methods for performing this operation on built-in types.

Incompatible Types Error: What, Why & How?

The incompatible types error indicates a situation where there is some expression that yields a value of a certain data type different from the one expected. This error implies that the Java compiler is unable to resolve a value assigned to a variable or returned by a method, because its type is incompatible with the one declared on the variable or method in question. Incompatible, in this context, means that the source type is both different from and unconvertible (by means of automatic type casting) to the declared type.

This might seem like a syntax error, but it is a logical error discovered in the semantic phase of compilation. The error message generated by the compiler indicates the line and the position where the type mismatch has occurred and specifies the incompatible types it has detected. This error is a generalization of the method X in class Y cannot be applied to given types and the constructor X in class Y cannot be applied to given types errors discussed in [4].

The incompatible types error most often occurs when manual or explicit conversion between types is required, but it can also happen by accident when using an incorrect API, usually involving the use of an incorrect reference type or the invocation of an incorrect method with an identical or similar name.

Incompatible Types Error Examples

Explicit type casting

Assigning a value of one primitive type to another can happen in one of two directions. Either from a type of a smaller size to one of a larger size (upcasting), or from a larger-sized type to a smaller-sized type (downcasting). In the case of the former, the data will take up more space but will be intact as the larger type can accommodate any value of the smaller type. So the conversion here is done automatically. However, converting from a larger-sized type to a smaller one necessitates explicit casting because some data may be lost in the process.

Fig. 1(a) shows how attempting to assign the values of the two double variables a and b to the int variables x and y results in the incompatible types error at compile-time. Prefixing the variables on the right-hand side of the assignment with the int data type in parenthesis (lines 10 & 11 in Fig. 1(b)) fixes the issue. Note how both variables lost their decimal part as a result of the conversion, but only one kept its original value—this is exactly why the error message reads possible lossy conversion from double to int and why the incompatible types error is raised in this scenario. By capturing this error, the compiler prevents accidental loss of data and forces the programmer to be deliberate about the conversion. The same principle applies to downcasting reference types, although the process is slightly different as polymorphism gets involved [5].

Источник

Автор оригинала: baeldung.

1. Обзор

В этом кратком руководстве мы обсудим концепцию преобразования с потерями в Java и причину этого.

В то же время мы рассмотрим некоторые удобные методы преобразования, чтобы избежать этой ошибки.

2. Преобразование С Потерями

Преобразование с потерями-это просто потеря информации при обработке данных.

В Java это соответствует возможности потери значения или точности переменной при преобразовании одного типа в другой.

Когда мы пытаемся назначить переменную типа большого размера типу меньшего размера , Java генерирует ошибку, несовместимые типы: возможное преобразование с потерями , при компиляции кода.

Например, давайте попробуем назначить long для int :

long longNum = 10;
int intNum = longNum;

Java выдаст ошибку при компиляции этого кода:

incompatible types: possible lossy conversion from long to int

Здесь Java найдет long и int несовместимыми и приведет к ошибке преобразования с потерями. Потому что могут быть длинные значения за пределами int диапазона от -2,147,483,648 до 2,147,483,647.

Аналогично, давайте попробуем назначить float a long :

float floatNum = 10.12f;
long longNum = floatNum;

incompatible types: possible lossy conversion from float to long

Поскольку float может иметь десятичные значения, которые не имеют соответствующего long значения. Поэтому мы получим ту же ошибку.

Аналогично, присвоение double номера int приведет к той же ошибке:

double doubleNum = 1.2;
int intNum = doubleNum;

incompatible types: possible lossy conversion from double to int

Значения double могут быть слишком большими или слишком маленькими для int , и десятичные значения будут потеряны при преобразовании. Следовательно, это потенциальное преобразование с потерями.

Кроме того, мы можем столкнуться с этой ошибкой при выполнении простого вычисления:

int fahrenheit = 100;
int celcius = (fahrenheit - 32) * 5.0 / 9.0;

Когда double умножается на int , мы получаем результат в double . Следовательно, это также потенциальное преобразование с потерями.

Поэтому несовместимые типы в преобразовании с потерями могут иметь разные размеры или типы (целые или десятичные числа).

3. Примитивные Типы данных

В Java существует множество примитивных типов данных, доступных с соответствующими классами-оболочками .

Далее давайте составим удобный список всех возможных преобразований с потерями в Java:

• short to byte или char
• char to байт или короткий
• int to byte , short или char
• long to byte , short , char или int
• float to byte , short , char , int или long
• double to byte , short , char , int , long или float

Обратите внимание, что хотя short и char имеют одинаковый размер. Тем не менее, преобразование из short в char приводит к потерям, поскольку char является типом данных без знака .

4. Методы преобразования

4.1. Преобразование Между Примитивными Типами

Простой способ преобразования примитивов, чтобы избежать преобразования с потерями,-это понижение; другими словами, приведение типа большего размера к типу меньшего размера. Следовательно, это также называется сужением примитивного преобразования.

Например, давайте преобразуем длинное число в короткое с помощью понижающей передачи :

long longNum = 24;
short shortNum = (short) longNum;
assertEquals(24, shortNum);

Аналогично, давайте преобразуем double в int :

double doubleNum = 15.6;
int integerNum = (int) doubleNum;
assertEquals(15, integerNum);

Однако следует отметить, что преобразование типа большого размера со слишком большими или слишком маленькими значениями в тип меньшего размера с помощью понижения может привести к неожиданным значениям.

Давайте преобразуем длинные значения за пределами диапазона короткие :

long largeLongNum = 32768; 
short minShortNum = (short) largeLongNum;
assertEquals(-32768, minShortNum);

long smallLongNum = -32769;
short maxShortNum = (short) smallLongNum;
assertEquals(32767, maxShortNum);

Если мы внимательно проанализируем конверсию, то увидим, что это не ожидаемые значения.

Другими словами, когда Java достигает наибольшего значения типа малого размера при преобразовании из типа большого размера, следующее число является наименьшим значением типа малого размера и наоборот.

Давайте разберемся в этом на примерах. Когда большое длинное число со значением 32768 преобразуется в короткое , значение короткое число 1 равно -32768 . Поскольку максимальное значение short равно 32767, поэтому Java переходит к следующему минимальному значению short.

Аналогично, когда маленькое длинное число преобразуется в короткое . Значение short Num2 равно 32767, поскольку Java переходит к следующему максимальному значению short .

Кроме того, давайте посмотрим, что произойдет, когда мы преобразуем максимальные и минимальные значения a long в int :

long maxLong = Long.MAX_VALUE; 
int minInt = (int) maxLong;
assertEquals(-1, minInt);

long minLong = Long.MIN_VALUE;
int maxInt = (int) minLong;
assertEquals(0, maxInt);

4.2. Преобразование между объектами-оболочками и примитивными типами

Чтобы напрямую преобразовать объект-оболочку в примитив, мы можем использовать различные методы в классах-оболочках, такие как int Value () , shortValue() и longValue() . Это называется распаковка .

Например, давайте преобразуем объект Float в объект long :

Float floatNum = 17.564f;
long longNum = floatNum.longValue();
assertEquals(17, longNum);

Кроме того, если мы посмотрим на реализацию long Value или аналогичных методов, мы найдем применение сужающего примитивного преобразования:

public long longValue() {
    return (long) value;
}

Однако иногда следует избегать сужения примитивного преобразования, чтобы сохранить ценную информацию:

Double doubleNum = 15.9999;
long longNum = doubleNum.longValue();
assertEquals(15, longNum);

После преобразования значение long Num будет равно 15. Однако двойное число равно 15.9999, что очень близко к 16.

Вместо этого мы можем использовать Math.round() для преобразования в ближайшее целое число:

Double doubleNum = 15.9999;
long longNum = Math.round(doubleNum);

assertEquals(16, longNum);

4.3. Преобразование Между Объектами-Оболочками

Для этого давайте воспользуемся уже рассмотренными методами преобразования.

Сначала мы преобразуем объект-оболочку в примитивное значение, опустим его и преобразуем в другой объект-оболочку . Другими словами, мы будем выполнять техники распаковки, даункастинга и бокса.

Например, давайте преобразуем объект Double в объект Integer :

Double doubleNum = 10.3;
double dbl = doubleNum.doubleValue(); // unboxing
int intgr = (int) dbl; // downcasting
Integer intNum = Integer.valueOf(intgr);
assertEquals(Integer.valueOf(10), intNum);

Наконец, мы используем Integer . valueOf() для преобразования примитивного типа int в Целое число объект. Этот тип преобразования называется boxing .

5. Заключение

В этой статье мы исследовали концепцию преобразования с потерями в Java с помощью ряда примеров. Кроме того, мы также составили удобный список всех возможных конверсий с потерями.

Попутно мы определили сужение примитивного преобразования как простой метод преобразования примитивных чисел и избежания ошибки преобразования с потерями.

В то же время мы также изучили дополнительные удобные методы числовых преобразований в Java.

Реализации кода для этой статьи можно найти на GitHub .

Click on the blue words in the upper left corner and follow “Big Guy outside the pot”

Focus on sharing the latest foreign technology content

1. An overview of the
In this quick tutorial, we’ll discuss the concept of lossy transformations in Java and the reasons behind them.
In the meantime, we’ll explore some convenient transformation techniques to avoid this error.
2. Lossy conversion
Lossy transformation is the loss of information while processing data.
In Java, this corresponds to the possibility of losing variable values or precision when converting from one type to another.
When we try to convert a variable of a high-level type to a low-level type, Java will generate an incorrect, incompatible type when compiling the code: a potentially lossy conversion.
For example, let’s try assigning a long value to an int value:

long longNum = 10;	
int intNum = longNum;

When compiling this code, Java produces an error:

incompatible types: possible lossy conversion from long to int

Here, Java will find that long and int are incompatible and cause lossy conversion errors. Because you can have long values outside of the int range of -2,147,483,648 to 2,147,483,647.
Similarly, we try to assign a long to a float:

float floatNum = 10.12f;	
long longNum = floatNum;	
incompatible types: possible lossy conversion from float to long

Because floats can represent small values that don’t have a corresponding long type. Therefore, we will receive the same error.
Similarly, converting a double to an int results in the same error:

double doubleNum = 1.2;	
int intNum = doubleNum;	
incompatible types: possible lossy conversion from double to int

The double value may be too large or too small for an int value, and the small value will be lost in the conversion. Therefore, this is a potentially lossy transformation.
In addition, we may encounter this error when performing a simple calculation:

int fahrenheit = 100;	
int celcius = (fahrenheit - 32) * 5.0/9.0;

When a double is multiplied by an int, the result is a double. Therefore, it is also a potentially lossy transformation.
Therefore, incompatible types in lossy conversions can have different sizes or types (integer or decimal).
3. Basic data types
In Java, there are many basic data types and their corresponding wrapper classes.
Next, let’s make a list of all possible lossy transformations in Java:
short to byte or charchar to byte or shortint to byte, short or charlong to byte, short, char or intfloat to byte, short, char, int or longdouble to byte, short, char, int, long or float
Note that although short and CHAR have the same range. However, the conversion from short to char is lossy because char is an unsigned data type.
4. Transform technology
4.1. Conversion between two basic data types
The simple way to avoid lossy conversions for primitive types is by casting down; In other words, cast a high-level type to a low-level type. For this reason, it is also called a narrowing primitive conversion.
For example, let’s convert long to short using a downward cast:

long longNum = 24;	
short shortNum = (short) longNum;	
assertEquals(24, shortNum);

Similarly, convert a double to an int:

double doubleNum = 15.6;	
int integerNum = (int) doubleNum;	
assertEquals(15, integerNum);

However, we should note that casting down a high-level type with a value too large or too small to a low-level type can result in unexpected values.
We convert a long value to a value outside the range of the short type:

long largeLongNum = 32768; 	
short minShortNum = (short) largeLongNum;	
assertEquals(-32768, minShortNum);	

	
long smallLongNum = -32769;	
short maxShortNum = (short) smallLongNum;	
assertEquals(32767, maxShortNum);

If we look closely at the transformations, we see that these are not the expected values.
In other words, when Java is converting from a high-level type to a low-level type, when the maximum value of the low-level type is reached, the next value is the minimum value of the low-level type, and vice versa.
Let’s look at an example to understand this. When largeLongNum with a value of 32768 is converted to short, the value of shortNum1 is -32768. Since the maximum value of short is 32767, Java will select the next minimum value of short.
Similarly, when smallLongNum is converted to short. ShortNum2 has a value of 32767, which Java USES as the next maximum for Short.
Also, let’s look at what happens when we convert the maximum and minimum values of long to ints:

long maxLong = Long.MAX_VALUE; 	
int minInt = (int) maxLong;	
assertEquals(-1, minInt);	

	
long minLong = Long.MIN_VALUE;	
int maxInt = (int) minLong;	
assertEquals(0, maxInt);

4.2. Convert between wrapper objects and primitive types
To convert the wrapper object directly to the base type, we can use various methods in the wrapper class, such as intValue(), shortValue(), and longValue(). This is called unpacking.
For example, let’s convert a Float object to a long:

Float floatNum = 17.564f;	
long longNum = floatNum.longValue();	
assertEquals(17, longNum);

In addition, if we look at the implementation of longValue or similar methods, we will find the use of narrowing the original transformation:

public long longValue() {	
    return (long) value;	
}

However, sometimes you should avoid narrowing the original transformation to preserve valuable information:

Double doubleNum = 15.9999;	
long longNum = doubleNum.longValue();	
assertEquals(15, longNum);

After conversion, the value of longNum is 15. However, doubleNum is 15.9999, very close to 16.
Instead, we can use math. round() to convert to the nearest integer:

Double doubleNum = 15.9999;	
long longNum = Math.round(doubleNum);	
assertEquals(16, longNum);

4.3. Convert between wrapper objects
To do this, let’s use the transformation techniques we’ve already discussed.
First, we will convert the wrapper object to a base value, cast it down and convert it to another wrapper object. In other words, we will perform unboxing, downcast, and boxing techniques.
For example, let’s convert a Double object to an Integer object:

Double doubleNum = 10.3;	
double dbl = doubleNum.doubleValue(); // unboxing	
int intgr = (int) dbl; // downcasting	
Integer intNum = Integer.valueOf(intgr);	
assertEquals(Integer.valueOf(10), intNum);

Finally, we use intet.valueof () to convert the basic type int to an Integer object. This type of conversion is called boxing.
5. To summarize
In this article, we explored the concept of lossy transformations in Java through examples. In addition, we have written a handy list of all possible lossy transformations in Java.
Along the way, we’ve determined that narrowing the original transform is an easy way to transform the base type and avoid lossy conversion errors.
At the same time, we explored other convenient techniques for numeric conversion in Java.
The code implementation for this article can be found on the GitHub project.  
From spring for All community Translation group

Recently, I have translated the articles into PDF.
Reply in the background of official account: 002 can get oh ~
The content of PDF will be updated continuously in the future, please look forward to it!

● Top 10 mistakes you make using the Spring Framework
● Why Spring as the Java framework?
●Solr full-text search
Top right button to share with more people ~

Here we are. Click and watch before you go

posted 6 years ago

• 
• 
  
  
  

  Number of slices to send:

  Optional ‘thank-you’ note:

  
  
  

• 
•