> ## Documentation Index
> Fetch the complete documentation index at: https://ollm-opencomic-ai-bin-7.mintlify.site/llms.txt
> Use this file to discover all available pages before exploring further.

# closest

> Find closest value in array

## Signature

```typescript theme={null}
OpenComicAI.closest(array: number[], target: number): number
```

## Description

Finds and returns the value in an array that is numerically closest to a target value. This utility method is commonly used to find the nearest supported scale factor or noise level when the exact desired value is not available.

For example, if a model supports scales `[2, 3, 4]` and you want to upscale by `3.5x`, this method will return `4` as the closest supported scale.

## Parameters

**array** `number[]` *required*

Array of numbers to search. Typically contains supported scale factors or noise levels from a model.

**target** `number` *required*

The target value to find the closest match for.

## Returns

**number** `number`

The value from the array that is numerically closest to the target. If two values are equally close, returns the smaller value.

## Examples

### Find closest supported scale

```typescript theme={null}
import OpenComicAI from 'opencomic-ai-bin';

const modelInfo = OpenComicAI.model('realcugan');
const desiredScale = 3.5;

// Find the closest supported scale
const closestScale = OpenComicAI.closest(modelInfo.scales, desiredScale);

console.log(`Closest scale to ${desiredScale}x: ${closestScale}x`);
// Output: Closest scale to 3.5x: 4x
```

### Find closest noise level

```typescript theme={null}
import OpenComicAI from 'opencomic-ai-bin';

const modelInfo = OpenComicAI.model('waifu2x-models-cunet');

if (modelInfo.noise) {
  const desiredNoise = 1.5;
  const closestNoise = OpenComicAI.closest(modelInfo.noise, desiredNoise);
  
  console.log(`Closest noise level to ${desiredNoise}: ${closestNoise}`);
  // Output: Closest noise level to 1.5: 2
}
```

### Validate and adjust scale

```typescript theme={null}
import OpenComicAI from 'opencomic-ai-bin';

function getValidScale(model: string, desiredScale: number): number {
  const modelInfo = OpenComicAI.model(model);
  
  // Check if exact scale is supported
  if (modelInfo.scales.includes(desiredScale)) {
    return desiredScale;
  }
  
  // Find closest supported scale
  const closestScale = OpenComicAI.closest(modelInfo.scales, desiredScale);
  console.warn(
    `Scale ${desiredScale}x not supported by ${model}. ` +
    `Using ${closestScale}x instead.`
  );
  
  return closestScale;
}

const scale = getValidScale('realcugan', 5);
// Output: Scale 5x not supported by realcugan. Using 4x instead.
// Returns: 4
```

### Find closest from custom array

```typescript theme={null}
import OpenComicAI from 'opencomic-ai-bin';

const availableSizes = [256, 512, 1024, 2048];
const desiredSize = 800;

const closestSize = OpenComicAI.closest(availableSizes, desiredSize);

console.log(`Closest size to ${desiredSize}: ${closestSize}`);
// Output: Closest size to 800: 1024
```

### Dynamic scale selection

```typescript theme={null}
import OpenComicAI from 'opencomic-ai-bin';

async function upscaleToTargetSize(
  inputPath: string,
  outputPath: string,
  targetWidth: number,
  currentWidth: number,
  model: string
) {
  // Calculate desired scale factor
  const desiredScale = targetWidth / currentWidth;
  
  // Get model info and find closest supported scale
  const modelInfo = OpenComicAI.model(model);
  const scale = OpenComicAI.closest(modelInfo.scales, desiredScale);
  
  console.log(
    `Target: ${desiredScale.toFixed(2)}x, Using: ${scale}x`
  );
  
  // Process with adjusted scale
  await OpenComicAI.pipeline(inputPath, outputPath, [
    { model, scale }
  ]);
}

await upscaleToTargetSize(
  './input.jpg',
  './output.jpg',
  3200,  // target width
  1000,  // current width
  'realcugan'
);
// Output: Target: 3.20x, Using: 3x
```

### Handling edge cases

```typescript theme={null}
import OpenComicAI from 'opencomic-ai-bin';

const values = [2, 3, 4];

// Exact match
console.log(OpenComicAI.closest(values, 3));
// Output: 3

// Below minimum
console.log(OpenComicAI.closest(values, 1));
// Output: 2

// Above maximum
console.log(OpenComicAI.closest(values, 10));
// Output: 4

// Between two values (equidistant)
console.log(OpenComicAI.closest(values, 2.5));
// Output: 2 (returns the smaller value when equidistant)
```

### Build UI with valid options

```typescript theme={null}
import OpenComicAI from 'opencomic-ai-bin';

function createScaleSlider(model: string) {
  const modelInfo = OpenComicAI.model(model);
  const minScale = Math.min(...modelInfo.scales);
  const maxScale = Math.max(...modelInfo.scales);
  
  return {
    min: minScale,
    max: maxScale,
    step: 0.1,
    getValue: (sliderValue: number) => 
      OpenComicAI.closest(modelInfo.scales, sliderValue),
    supportedValues: modelInfo.scales,
  };
}

const slider = createScaleSlider('realcugan');
console.log(slider);
// {
//   min: 2,
//   max: 4,
//   step: 0.1,
//   getValue: [Function],
//   supportedValues: [2, 3, 4]
// }
```

## Related

* [model](https://ollm-opencomic-ai-bin-7.mintlify.site/api/model.md) - Get model information with supported scales
* [pipeline](https://ollm-opencomic-ai-bin-7.mintlify.site/api/pipeline.md) - Process images with validated scales
* [ModelObject](https://ollm-opencomic-ai-bin-7.mintlify.site/api/types.md#modelobject) - Model information including scales and noise levels


This documentation is built and hosted on [Mintlify](https://mintlify.com), a developer documentation platform.