aroundPrecision

1
2
3
results = index.search('query', {
  aroundPrecision: 100 # 100 meters precision
})

1
2
3
4
5
index.search('query', {
  aroundPrecision: 100 // 100 meters precision
}).then(({ hits }) => {
  console.log(hits);
});

1
2
3
results = index.search('query', {
    'aroundPrecision': 100  # 100 meters precision
})

1
2
3
4
5
6
7
8
let query = Query("query")
  .set(\.aroundPrecision, to: [100]) // 100 meters precision

index.search(query: query) { result in
  if case .success(let response) = result {
    print("Response: \(response)")
  }
}

1
2
3
4
5
6
7
8
val query = query("query") {
aroundPrecision = AroundPrecision.Ranges(
    0 until 25, // 25 meters precision by default
    2000 until 1000 // 1,000 meters precision after 2 km
  )
}

index.search(query)

1
2
3
4
index.Search<T>(new Query("query")
{
    AroundPrecision = 100 // 100 meters precision
});

1
2
3
index.search(new Query("").setAroundPrecision(
    Collections.singletonList(new AroundPrecision(0, 100)) // 100 meters precision
));

1
2
3
4
res, err := index.Search(
  "query",
  opt.AroundPrecision(opt.AroundPrecisionRange{From: 0, Value: 100}) // 100 meters precision
)

1
2
3
4
5
6
client.execute {
  search into "myIndex" query Query(
    query = Some("query"),
    aroundPrecision = Some(100) // 100 meters precision
  )
}

1
2
3
4
5
6
results = index.search('query', {
  aroundPrecision: [
    {from: 0, value: 25}, # 25 meters precision by default
    {from: 2000, value: 1000} # 1,000 meters precision after 2 km
  ]
})

1
2
3
4
5
6
7
8
index.search('query', {
  aroundPrecision: [
    { from: 0, value: 25 }, // 25 meters precision by default
    { from: 2000, value: 1000 }, // 1,000 meters precision after 2 km
  ],
}).then(({ hits }) => {
  console.log(hits);
});

1
2
3
4
5
6
results = index.search('query', {
    'aroundPrecision': [
        {'from': 0, 'value': 25},  # 25 meters precision by default
        {'from': 2000, 'value': 1000}  # 1,000 meters precision after 2 km
    ]
})

1
2
3
4
5
6
7
8
9
10
11
let query = Query("query")
  .set(\.aroundPrecision, to: [
    .init(from: 0, value: 25), // 25 meters precision by default
    .init(from: 2000, value: 1000) // 1,000 meters precision after 2 km
  ])

index.search(query: query) { result in
  if case .success(let response) = result {
    print("Response: \(response)")
  }
}

1
2
3
4
5
val query = query("query") {
    aroundPrecision = AroundPrecision.Int(100) // TODO: update snippet
}

index.search(query)

1
2
3
4
5
6
7
8
index.Search<T>(new Query("query")
{
    AroundPrecision = new List<AroundPrecision>
    {
       new AroundPrecision { From = 0 , Value = 25 }, // 25 meters precision by default
       new AroundPrecision { From = 0 , Value = 1000 } // 1,000 meters precision after 2 km
    }
});

1
2
3
4
5
6
7
8
9
index.search(
  new Query("query")
    .setAroundPrecision(
        Arrays.asList(
          new AroundPrecision(0, 25),     // 25 meters precision by default
          new AroundPrecision(2000, 1000) // 1,000 meters precision after 2 km
        )
    )
);

1
2
3
4
5
6
7
res, err := index.Search(
  "query",
  opt.AroundPrecision(
    opt.AroundPrecisionRange{From: 0, Value: 25},      // 25 meters precision by default
    opt.AroundPrecisionRange{From: 2000, Value: 1000}, // 1,000 meters precision after 2 km
  ),
)

1
// The Scala API client does not support non-linear precision.