* to the JDK until JDK 7.
   *
   * @param a the first {@code float} to compare
   * @param b the second {@code float} to compare
   * @return the result of invoking {@link Float#compare(float, float)}
   */
  @InlineMe(replacement = "Float.compare(a, b)")
  public static int compare(float a, float b) {
    return Float.compare(a, b);
  }

  /**

        serialization_alias: Union[str, None] = None,
        title: Optional[str] = None,
        description: Optional[str] = None,
        gt: Optional[float] = None,
        ge: Optional[float] = None,
        lt: Optional[float] = None,
        le: Optional[float] = None,
        min_length: Optional[int] = None,
        max_length: Optional[int] = None,
        pattern: Optional[str] = None,
        regex: Annotated[

def test_route_converters_float():
    # Test float conversion
    response = client.get("/float/25.5")
    assert response.status_code == 200, response.text
    assert response.json() == {"float": 25.5}
    assert app.url_path_for("float_convertor", param=25.5) == "/float/25.5"  # type: ignore


def test_route_converters_path():
    # Test path conversion

pkg math/big, method (*Float) Mode() RoundingMode
pkg math/big, method (*Float) Mul(*Float, *Float) *Float
pkg math/big, method (*Float) Neg(*Float) *Float
pkg math/big, method (*Float) Parse(string, int) (*Float, int, error)
pkg math/big, method (*Float) Prec() uint
pkg math/big, method (*Float) Quo(*Float, *Float) *Float
pkg math/big, method (*Float) Rat(*Rat) (*Rat, Accuracy)
pkg math/big, method (*Float) Set(*Float) *Float

def get_path_param_gt(item_id: float = Path(gt=3)):
    return item_id


@app.get("/path/param-gt0/{item_id}")
def get_path_param_gt0(item_id: float = Path(gt=0)):
    return item_id


@app.get("/path/param-ge/{item_id}")
def get_path_param_ge(item_id: float = Path(ge=3)):
    return item_id


@app.get("/path/param-lt/{item_id}")
def get_path_param_lt(item_id: float = Path(lt=3)):
    return item_id

    Map<Float, String> m = ImmutableMap.of(4.0f, "A", 3.0f, "B", 2.0f, "C", 1.0f, "D");
    Predicate<? super Integer> h = Predicates.equalTo(42);
    Function<? super String, Integer> g = new HashCodeFunction();
    Function<Float, String> f = Functions.forMap(m, "F");

    Predicate<Float> p1 = Predicates.compose(Predicates.compose(h, g), f);
    Predicate<Float> p2 = Predicates.compose(h, Functions.compose(g, f));

from typing import Union

from fastapi import FastAPI
from pydantic import BaseModel


class Item(BaseModel):
    name: str
    description: Union[str, None] = None
    price: float
    tax: Union[float, None] = None


app = FastAPI()


@app.post("/items/")
async def create_item(item: Item):

	VFMULVV		X10, V2, V3			// ERROR "expected vector register in vs1 position"
	VFMULVF		X10, V2, V3			// ERROR "expected float register in rs1 position"
	VFDIVVV		X10, V2, V3			// ERROR "expected vector register in vs1 position"
	VFDIVVF		X10, V2, V3			// ERROR "expected float register in rs1 position"
	VFRDIVVF	X10, V2, V3			// ERROR "expected float register in rs1 position"

from fastapi import FastAPI
from pydantic import BaseModel

app = FastAPI()


class Item(BaseModel):
    name: str
    description: str | None = None
    price: float
    tax: float | None = None
    tags: list[str] = []


@app.post("/items/")
async def create_item(item: Item) -> Item:
    return item


@app.get("/items/")
async def read_items() -> list[Item]:
    return [

from fastapi import FastAPI
from pydantic import BaseModel

app = FastAPI()


class Item(BaseModel):
    name: str
    description: str | None = None
    price: float
    tax: float | None = None

    model_config = {
        "json_schema_extra": {
            "examples": [
                {
                    "name": "Foo",
                    "description": "A very nice Item",
                    "price": 35.4,