Skip to content

[BUG] arm64 CPU backend fails JIT compile when using Float16 #3080

@Joannis

Description

@Joannis

Describe the bug
When you configure MLX (through MLX-Swift in my case) to run on a arm64 Linux machine, JIT compilation fails when it involves a float16.

To Reproduce
I have a draft PR for MLX-swift-LM that demonstrates this in a Dockerfile:
ml-explore/mlx-swift-lm#87

Expected behavior
CPU backend, although slow, successfully JIT compiles the code and runs some inference.

Desktop (please complete the following information):

FROM --platform=linux/arm64 swift:6.2.3-jammy AS base

RUN apt-get update && apt-get install -y \
    libblas-dev \
    liblapack-dev \
    liblapacke-dev \
    libopenblas-dev \
    gfortran \
    g++ \
    && rm -rf /var/lib/apt/lists/* 

WORKDIR /app

FROM base AS builder

COPY . .
RUN swift build --product WebExample --static-swift-stdlib -Xlinker -s -v

# Final image
FROM base

# Copy executable from SwiftPM build directory
COPY --from=builder /app/.build/debug/WebExample /app/WebExample

EXPOSE 8080

CMD ["./WebExample"]

Additional context

MLX/ErrorHandler.swift:343: Fatal error: [Compile::eval_cpu] Failed to compile function     
  Bf4ISigmoidACf4OMultiplyAB_V__6142509188972423790_contiguous: Failed to execute             
  command with return code 1: "g++ -std=c++17 -O3 -Wall -fPIC -shared                         
  "/tmp/mlx/0.24.2/cpu/Bf4ISigmoidACf4OMultiplyAB_V__6142509188972423790_contiguous.cpp"      
  -o "/tmp/mlx/0.24.2/cpu/libBf4ISigmoidACf4OMultiplyAB_V__6142509188972423790_contiguous     
  .so" 2>&1", the output is: /tmp/mlx/0.24.2/cpu/Bf4ISigmoidACf4OMultiplyAB_V__6142509188     
  972423790_contiguous.cpp:10:9: error: 'float16_t' has not been declared in '::'             
  10 | using ::float16_t;                                                                     
  |         ^~~~~~~~~                                                                         
  /tmp/mlx/0.24.2/cpu/Bf4ISigmoidACf4OMultiplyAB_V__6142509188972423790_contiguous.cpp:74     
  :14: error: declaration of 'operator+' as non-function                                      
  74 | inline float operator+(float16_t lhs, bfloat16_t rhs) { return                         
  static_cast<float>(lhs) + static_cast<float>(rhs); } inline float operator+(bfloat16_t      
  lhs, float16_t rhs) { return static_cast<float>(lhs) + static_cast<float>(rhs); }           
  |              ^~~~~~~~                                                                     
  /tmp/mlx/0.24.2/cpu/Bf4ISigmoidACf4OMultiplyAB_V__6142509188972423790_contiguous.cpp:74     
  :24: error: 'float16_t' was not declared in this scope; did you mean 'bfloat16_t'?          
  74 | inline float operator+(float16_t lhs, bfloat16_t rhs) { return                         
  static_cast<float>(lhs) + static_cast<float>(rhs); } inline float operator+(bfloat16_t      
  lhs, float16_t rhs) { return static_cast<float>(lhs) + static_cast<float>(rhs); }           
  |                        ^~~~~~~~~                                                          
  |                        bfloat16_t                                                         
  /tmp/mlx/0.24.2/cpu/Bf4ISigmoidACf4OMultiplyAB_V__6142509188972423790_contiguous.cpp:74     
  :50: error: expected primary-expression before 'rhs'                                        
  74 | inline float operator+(float16_t lhs, bfloat16_t rhs) { return                         
  static_cast<float>(lhs) + static_cast<float>(rhs); } inline float operator+(bfloat16_t      
  lhs, float16_t rhs) { return static_cast<float>(lhs) + static_cast<float>(rhs); }           
  |                                                  ^~~                                      
  /tmp/mlx/0.24.2/cpu/Bf4ISigmoidACf4OMultiplyAB_V__6142509188972423790_contiguous.cpp:74     
  :156: error: 'float16_t' has not been declared                                              
  74 | inline float operator+(float16_t lhs, bfloat16_t rhs) { return                         
  static_cast<float>(lhs) + static_cast<float>(rhs); } inline float operator+(bfloat16_t      
  lhs, float16_t rhs) { return static_cast<float>(lhs) + static_cast<float>(rhs); }           
  |                                                                                           
  ^~~~~~~~~                                                                                   
  /tmp/mlx/0.24.2/cpu/Bf4ISigmoidACf4OMultiplyAB_V__6142509188972423790_contiguous.cpp:74     
  :130: error: ambiguating new declaration of 'float                                          
  mlx::core::operator+(mlx::core::bfloat16_t, int)'                                           
  74 | inline float operator+(float16_t lhs, bfloat16_t rhs) { return                         
  static_cast<float>(lhs) + static_cast<float>(rhs); } inline float operator+(bfloat16_t      
  lhs, float16_t rhs) { return static_cast<float>(lhs) + static_cast<float>(rhs); }           
  |                                                                                           
  ^~~~~~~~                                                                                    
  /tmp/mlx/0.24.2/cpu/Bf4ISigmoidACf4OMultiplyAB_V__6142509188972423790_contiguous.cpp:46     
  :869: note: old declaration 'mlx::core::_MLX_BFloat16                                       
  mlx::core::operator+(mlx::core::_MLX_BFloat16, int32_t)'                                    
  46 | inline _MLX_BFloat16 operator+(_MLX_BFloat16 lhs, _MLX_BFloat16 rhs) { return          
  static_cast<float>(lhs) + static_cast<float>(rhs); }; inline float                          
  operator+(_MLX_BFloat16 lhs, float rhs) { return static_cast<float>(lhs) +                  
  static_cast<float>(rhs); } inline float operator+(float lhs, _MLX_BFloat16 rhs) {           
  return static_cast<float>(lhs) + static_cast<float>(rhs); }; inline double                  
  operator+(_MLX_BFloat16 lhs, double rhs) { return static_cast<double>(lhs) +                
  static_cast<double>(rhs); } inline double operator+(double lhs, _MLX_BFloat16 rhs) {        
  return static_cast<double>(lhs) + static_cast<double>(rhs); }; inline _MLX_BFloat16         
  operator+(_MLX_BFloat16 lhs, bool rhs) { return static_cast<float>(lhs) +                   
  static_cast<float>(rhs); } inline _MLX_BFloat16 operator+(bool lhs, _MLX_BFloat16 rhs)      
  { return static_cast<float>(lhs) + static_cast<float>(rhs); }; inline _MLX_BFloat16         
  operator+(_MLX_BFloat16 lhs, int32_t rhs) { return static_cast<float>(lhs) +                
  static_cast<float>(rhs); } inline _MLX_BFloat16 operator+(int32_t lhs, _MLX_BFloat16        
  rhs) { return static_cast<float>(lhs) + static_cast<float>(rhs); }; inline                  
  _MLX_BFloat16 operator+(_MLX_BFloat16 lhs, uint32_t rhs) { return                           
  static_cast<float>(lhs) + static_cast<float>(rhs); } inline _MLX_BFloat16                   
  operator+(uint32_t lhs, _MLX_BFloat16 rhs) { return static_cast<float>(lhs) +               
  static_cast<float>(rhs); }; inline _MLX_BFloat16 operator+(_MLX_BFloat16 lhs, int64_t       
  rhs) { return static_cast<float>(lhs) + static_cast<float>(rhs); } inline _MLX_BFloat16     
  operator+(int64_t lhs, _MLX_BFloat16 rhs) { return static_cast<float>(lhs) +                
  static_cast<float>(rhs); }; inline _MLX_BFloat16 operator+(_MLX_BFloat16 lhs, uint64_t      
  rhs) { return static_cast<float>(lhs) + static_cast<float>(rhs); } inline _MLX_BFloat16     
  operator+(uint64_t lhs, _MLX_BFloat16 rhs) { return static_cast<float>(lhs) +               
  static_cast<float>(rhs); };;                                                                
  |                                                                                           
                                                                                              
                                                                                              
                                                                                              
                                                                                              
                                                                                              
                                                                                              
                                                                                              
                                                                                              
                                                                                              
  ^~~~~~~~                                                                                    
  /tmp/mlx/0.24.2/cpu/Bf4ISigmoidACf4OMultiplyAB_V__6142509188972423790_contiguous.cpp:75     
  :14: error: declaration of 'operator-' as non-function                                      
  75 | inline float operator-(float16_t lhs, bfloat16_t rhs) { return                         
  static_cast<float>(lhs) - static_cast<float>(rhs); } inline float operator-(bfloat16_t      
  lhs, float16_t rhs) { return static_cast<float>(lhs) - static_cast<float>(rhs); }           
  |              ^~~~~~~~                                                                     
  /tmp/mlx/0.24.2/cpu/Bf4ISigmoidACf4OMultiplyAB_V__6142509188972423790_contiguous.cpp:75     
  :24: error: 'float16_t' was not declared in this scope; did you mean 'bfloat16_t'?          
  75 | inline float operator-(float16_t lhs, bfloat16_t rhs) { return                         
  static_cast<float>(lhs) - static_cast<float>(rhs); } inline float operator-(bfloat16_t      
  lhs, float16_t rhs) { return static_cast<float>(lhs) - static_cast<float>(rhs); }           
  |                        ^~~~~~~~~                                                          
  |                        bfloat16_t                                                         
  /tmp/mlx/0.24.2/cpu/Bf4ISigmoidACf4OMultiplyAB_V__6142509188972423790_contiguous.cpp:75     
  :50: error: expected primary-expression before 'rhs'                                        
  75 | inline float operator-(float16_t lhs, bfloat16_t rhs) { return                         
  static_cast<float>(lhs) - static_cast<float>(rhs); } inline float operator-(bfloat16_t      
  lhs, float16_t rhs) { return static_cast<float>(lhs) - static_cast<float>(rhs); }           
  |                                                  ^~~                                      
  /tmp/mlx/0.24.2/cpu/Bf4ISigmoidACf4OMultiplyAB_V__6142509188972423790_contiguous.cpp:75     
  :156: error: 'float16_t' has not been declared                                              
  75 | inline float operator-(float16_t lhs, bfloat16_t rhs) { return                         
  static_cast<float>(lhs) - static_cast<float>(rhs); } inline float operator-(bfloat16_t      
  lhs, float16_t rhs) { return static_cast<float>(lhs) - static_cast<float>(rhs); }           
  |                                                                                           
  ^~~~~~~~~                                                                                   
  /tmp/mlx/0.24.2/cpu/Bf4ISigmoidACf4OMultiplyAB_V__6142509188972423790_contiguous.cpp:75     
  :130: error: ambiguating new declaration of 'float                                          
  mlx::core::operator-(mlx::core::bfloat16_t, int)'                                           
  75 | inline float operator-(float16_t lhs, bfloat16_t rhs) { return                         
  static_cast<float>(lhs) - static_cast<float>(rhs); } inline float operator-(bfloat16_t      
  lhs, float16_t rhs) { return static_cast<float>(lhs) - static_cast<float>(rhs); }           
  |                                                                                           
  ^~~~~~~~                                                                                    
  /tmp/mlx/0.24.2/cpu/Bf4ISigmoidACf4OMultiplyAB_V__6142509188972423790_contiguous.cpp:47     
  :869: note: old declaration 'mlx::core::_MLX_BFloat16                                       
  mlx::core::operator-(mlx::core::_MLX_BFloat16, int32_t)'                                    
  47 | inline _MLX_BFloat16 operator-(_MLX_BFloat16 lhs, _MLX_BFloat16 rhs) { return          
  static_cast<float>(lhs) - static_cast<float>(rhs); }; inline float                          
  operator-(_MLX_BFloat16 lhs, float rhs) { return static_cast<float>(lhs) -                  
  static_cast<float>(rhs); } inline float operator-(float lhs, _MLX_BFloat16 rhs) {           
  return static_cast<float>(lhs) - static_cast<float>(rhs); }; inline double                  
  operator-(_MLX_BFloat16 lhs, double rhs) { return static_cast<double>(lhs) -                
  static_cast<double>(rhs); } inline double operator-(double lhs, _MLX_BFloat16 rhs) {        
  return static_cast<double>(lhs) - static_cast<double>(rhs); }; inline _MLX_BFloat16         
  operator-(_MLX_BFloat16 lhs, bool rhs) { return static_cast<float>(lhs) -                   
  static_cast<float>(rhs); } inline _MLX_BFloat16 operator-(bool lhs, _MLX_BFloat16 rhs)      
  { return static_cast<float>(lhs) - static_cast<float>(rhs); }; inline _MLX_BFloat16         
  operator-(_MLX_BFloat16 lhs, int32_t rhs) { return static_cast<float>(lhs) -                
  static_cast<float>(rhs); } inline _MLX_BFloat16 operator-(int32_t lhs, _MLX_BFloat16        
  rhs) { return static_cast<float>(lhs) - static_cast<float>(rhs); }; inline                  
  _MLX_BFloat16 operator-(_MLX_BFloat16 lhs, uint32_t rhs) { return                           
  static_cast<float>(lhs) - static_cast<float>(rhs); } inline _MLX_BFloat16                   
  operator-(uint32_t lhs, _MLX_BFloat16 rhs) { return static_cast<float>(lhs) -               
  static_cast<float>(rhs); }; inline _MLX_BFloat16 operator-(_MLX_BFloat16 lhs, int64_t       
  rhs) { return static_cast<float>(lhs) - static_cast<float>(rhs); } inline _MLX_BFloat16     
  operator-(int64_t lhs, _MLX_BFloat16 rhs) { return static_cast<float>(lhs) -                
  static_cast<float>(rhs); }; inline _MLX_BFloat16 operator-(_MLX_BFloat16 lhs, uint64_t      
  rhs) { return static_cast<float>(lhs) - static_cast<float>(rhs); } inline _MLX_BFloat16     
  operator-(uint64_t lhs, _MLX_BFloat16 rhs) { return static_cast<float>(lhs) -               
  static_cast<float>(rhs); };;                                                                
  |                                                                                           
                                                                                              
                                                                                              
                                                                                              
                                                                                              
                                                                                              
                                                                                              
                                                                                              
                                                                                              
                                                                                              
  ^~~~~~~~                                                                                    
  /tmp/mlx/0.24.2/cpu/Bf4ISigmoidACf4OMultiplyAB_V__6142509188972423790_contiguous.cpp:76     
  :14: error: declaration of 'operator*' as non-function                                      
  76 | inline float operator*(float16_t lhs, bfloat16_t rhs) { return                         
  static_cast<float>(lhs) * static_cast<float>(rhs); } inline float operator*(bfloat16_t      
  lhs, float16_t rhs) { return static_cast<float>(lhs) * static_cast<float>(rhs); }           
  |              ^~~~~~~~                                                                     
  /tmp/mlx/0.24.2/cpu/Bf4ISigmoidACf4OMultiplyAB_V__6142509188972423790_contiguous.cpp:76     
  :24: error: 'float16_t' was not declared in this scope; did you mean 'bfloat16_t'?          
  76 | inline float operator*(float16_t lhs, bfloat16_t rhs) { return                         
  static_cast<float>(lhs) * static_cast<float>(rhs); } inline float operator*(bfloat16_t      
  lhs, float16_t rhs) { return static_cast<float>(lhs) * static_cast<float>(rhs); }           
  |                        ^~~~~~~~~                                                          
  |                        bfloat16_t                                                         
  /tmp/mlx/0.24.2/cpu/Bf4ISigmoidACf4OMultiplyAB_V__6142509188972423790_contiguous.cpp:76     
  :50: error: expected primary-expression before 'rhs'                                        
  76 | inline float operator*(float16_t lhs, bfloat16_t rhs) { return                         
  static_cast<float>(lhs) * static_cast<float>(rhs); } inline float operator*(bfloat16_t      
  lhs, float16_t rhs) { return static_cast<float>(lhs) * static_cast<float>(rhs); }           
  |                                                  ^~~                                      
  /tmp/mlx/0.24.2/cpu/Bf4ISigmoidACf4OMultiplyAB_V__6142509188972423790_contiguous.cpp:76     
  :156: error: 'float16_t' has not been declared                                              
  76 | inline float operator*(float16_t lhs, bfloat16_t rhs) { return                         
  static_cast<float>(lhs) * static_cast<float>(rhs); } inline float operator*(bfloat16_t      
  lhs, float16_t rhs) { return static_cast<float>(lhs) * static_cast<float>(rhs); }           
  |                                                                                           
  ^~~~~~~~~                                                                                   
  /tmp/mlx/0.24.2/cpu/Bf4ISigmoidACf4OMultiplyAB_V__6142509188972423790_contiguous.cpp:76     
  :130: error: ambiguating new declaration of 'float                                          
  mlx::core::operator*(mlx::core::bfloat16_t, int)'                                           
  76 | inline float operator*(float16_t lhs, bfloat16_t rhs) { return                         
  static_cast<float>(lhs) * static_cast<float>(rhs); } inline float operator*(bfloat16_t      
  lhs, float16_t rhs) { return static_cast<float>(lhs) * static_cast<float>(rhs); }           
  |                                                                                           
  ^~~~~~~~                                                                                    
  /tmp/mlx/0.24.2/cpu/Bf4ISigmoidACf4OMultiplyAB_V__6142509188972423790_contiguous.cpp:48     
  :869: note: old declaration 'mlx::core::_MLX_BFloat16                                       
  mlx::core::operator*(mlx::core::_MLX_BFloat16, int32_t)'                                    
  48 | inline _MLX_BFloat16 operator*(_MLX_BFloat16 lhs, _MLX_BFloat16 rhs) { return          
  static_cast<float>(lhs) * static_cast<float>(rhs); }; inline float                          
  operator*(_MLX_BFloat16 lhs, float rhs) { return static_cast<float>(lhs) *                  
  static_cast<float>(rhs); } inline float operator*(float lhs, _MLX_BFloat16 rhs) {           
  return static_cast<float>(lhs) * static_cast<float>(rhs); }; inline double                  
  operator*(_MLX_BFloat16 lhs, double rhs) { return static_cast<double>(lhs) *                
  static_cast<double>(rhs); } inline double operator*(double lhs, _MLX_BFloat16 rhs) {        
  return static_cast<double>(lhs) * static_cast<double>(rhs); }; inline _MLX_BFloat16         
  operator*(_MLX_BFloat16 lhs, bool rhs) { return static_cast<float>(lhs) *                   
  static_cast<float>(rhs); } inline _MLX_BFloat16 operator*(bool lhs, _MLX_BFloat16 rhs)      
  { return static_cast<float>(lhs) * static_cast<float>(rhs); }; inline _MLX_BFloat16         
  operator*(_MLX_BFloat16 lhs, int32_t rhs) { return static_cast<float>(lhs) *                
  static_cast<float>(rhs); } inline _MLX_BFloat16 operator*(int32_t lhs, _MLX_BFloat16        
  rhs) { return static_cast<float>(lhs) * static_cast<float>(rhs); }; inline                  
  _MLX_BFloat16 operator*(_MLX_BFloat16 lhs, uint32_t rhs) { return                           
  static_cast<float>(lhs) * static_cast<float>(rhs); } inline _MLX_BFloat16                   
  operator*(uint32_t lhs, _MLX_BFloat16 rhs) { return static_cast<float>(lhs) *               
  static_cast<float>(rhs); }; inline _MLX_BFloat16 operator*(_MLX_BFloat16 lhs, int64_t       
  rhs) { return static_cast<float>(lhs) * static_cast<float>(rhs); } inline _MLX_BFloat16     
  operator*(int64_t lhs, _MLX_BFloat16 rhs) { return static_cast<float>(lhs) *                
  static_cast<float>(rhs); }; inline _MLX_BFloat16 operator*(_MLX_BFloat16 lhs, uint64_t      
  rhs) { return static_cast<float>(lhs) * static_cast<float>(rhs); } inline _MLX_BFloat16     
  operator*(uint64_t lhs, _MLX_BFloat16 rhs) { return static_cast<float>(lhs) *               
  static_cast<float>(rhs); };;                                                                
  |                                                                                           
                                                                                              
                                                                                              
                                                                                              
                                                                                              
                                                                                              
                                                                                              
                                                                                              
                                                                                              
                                                                                              
  ^~~~~~~~                                                                                    
  /tmp/mlx/0.24.2/cpu/Bf4ISigmoidACf4OMultiplyAB_V__6142509188972423790_contiguous.cpp:77     
  :14: error: declaration of 'operator/' as non-function                                      
  77 | inline float operator/(float16_t lhs, bfloat16_t rhs) { return                         
  static_cast<float>(lhs) / static_cast<float>(rhs); } inline float operator/(bfloat16_t      
  lhs, float16_t rhs) { return static_cast<float>(lhs) / static_cast<float>(rhs); }           
  |              ^~~~~~~~                                                                     
  /tmp/mlx/0.24.2/cpu/Bf4ISigmoidACf4OMultiplyAB_V__6142509188972423790_contiguous.cpp:77     
  :24: error: 'float16_t' was not declared in this scope; did you mean 'bfloat16_t'?          
  77 | inline float operator/(float16_t lhs, bfloat16_t rhs) { return                         
  static_cast<float>(lhs) / static_cast<float>(rhs); } inline float operator/(bfloat16_t      
  lhs, float16_t rhs) { return static_cast<float>(lhs) / static_cast<float>(rhs); }           
  |                        ^~~~~~~~~                                                          
  |                        bfloat16_t                                                         
  /tmp/mlx/0.24.2/cpu/Bf4ISigmoidACf4OMultiplyAB_V__6142509188972423790_contiguous.cpp:77     
  :50: error: expected primary-expression before 'rhs'                                        
  77 | inline float operator/(float16_t lhs, bfloat16_t rhs) { return                         
  static_cast<float>(lhs) / static_cast<float>(rhs); } inline float operator/(bfloat16_t      
  lhs, float16_t rhs) { return static_cast<float>(lhs) / static_cast<float>(rhs); }           
  |                                                  ^~~                                      
  /tmp/mlx/0.24.2/cpu/Bf4ISigmoidACf4OMultiplyAB_V__6142509188972423790_contiguous.cpp:77     
  :156: error: 'float16_t' has not been declared                                              
  77 | inline float operator/(float16_t lhs, bfloat16_t rhs) { return                         
  static_cast<float>(lhs) / static_cast<float>(rhs); } inline float operator/(bfloat16_t      
  lhs, float16_t rhs) { return static_cast<float>(lhs) / static_cast<float>(rhs); }           
  |                                                                                           
  ^~~~~~~~~                                                                                   
  /tmp/mlx/0.24.2/cpu/Bf4ISigmoidACf4OMultiplyAB_V__6142509188972423790_contiguous.cpp:77     
  :130: error: ambiguating new declaration of 'float                                          
  mlx::core::operator/(mlx::core::bfloat16_t, int)'                                           
  77 | inline float operator/(float16_t lhs, bfloat16_t rhs) { return                         
  static_cast<float>(lhs) / static_cast<float>(rhs); } inline float operator/(bfloat16_t      
  lhs, float16_t rhs) { return static_cast<float>(lhs) / static_cast<float>(rhs); }           
  |                                                                                           
  ^~~~~~~~                                                                                    
  /tmp/mlx/0.24.2/cpu/Bf4ISigmoidACf4OMultiplyAB_V__6142509188972423790_contiguous.cpp:49     
  :869: note: old declaration 'mlx::core::_MLX_BFloat16                                       
  mlx::core::operator/(mlx::core::_MLX_BFloat16, int32_t)'                                    
  49 | inline _MLX_BFloat16 operator/(_MLX_BFloat16 lhs, _MLX_BFloat16 rhs) { return          
  static_cast<float>(lhs) / static_cast<float>(rhs); }; inline float                          
  operator/(_MLX_BFloat16 lhs, float rhs) { return static_cast<float>(lhs) /                  
  static_cast<float>(rhs); } inline float operator/(float lhs, _MLX_BFloat16 rhs) {           
  return static_cast<float>(lhs) / static_cast<float>(rhs); }; inline double                  
  operator/(_MLX_BFloat16 lhs, double rhs) { return static_cast<double>(lhs) /                
  static_cast<double>(rhs); } inline double operator/(double lhs, _MLX_BFloat16 rhs) {        
  return static_cast<double>(lhs) / static_cast<double>(rhs); }; inline _MLX_BFloat16         
  operator/(_MLX_BFloat16 lhs, bool rhs) { return static_cast<float>(lhs) /                   
  static_cast<float>(rhs); } inline _MLX_BFloat16 operator/(bool lhs, _MLX_BFloat16 rhs)      
  { return static_cast<float>(lhs) / static_cast<float>(rhs); }; inline _MLX_BFloat16         
  operator/(_MLX_BFloat16 lhs, int32_t rhs) { return static_cast<float>(lhs) /                
  static_cast<float>(rhs); } inline _MLX_BFloat16 operator/(int32_t lhs, _MLX_BFloat16        
  rhs) { return static_cast<float>(lhs) / static_cast<float>(rhs); }; inline                  
  _MLX_BFloat16 operator/(_MLX_BFloat16 lhs, uint32_t rhs) { return                           
  static_cast<float>(lhs) / static_cast<float>(rhs); } inline _MLX_BFloat16                   
  operator/(uint32_t lhs, _MLX_BFloat16 rhs) { return static_cast<float>(lhs) /               
  static_cast<float>(rhs); }; inline _MLX_BFloat16 operator/(_MLX_BFloat16 lhs, int64_t       
  rhs) { return static_cast<float>(lhs) / static_cast<float>(rhs); } inline _MLX_BFloat16     
  operator/(int64_t lhs, _MLX_BFloat16 rhs) { return static_cast<float>(lhs) /                
  static_cast<float>(rhs); }; inline _MLX_BFloat16 operator/(_MLX_BFloat16 lhs, uint64_t      
  rhs) { return static_cast<float>(lhs) / static_cast<float>(rhs); } inline _MLX_BFloat16     
  operator/(uint64_t lhs, _MLX_BFloat16 rhs) { return static_cast<float>(lhs) /               
  static_cast<float>(rhs); };;                                                                
  |                                                                                           
                                                                                              
                                                                                              
                                                                                              
                                                                                              
                                                                                              
                                                                                              
                                                                                              
                                                                                              
                                                                                              
  ^~~~~~~~                                                                                    
  /tmp/mlx/0.24.2/cpu/Bf4ISigmoidACf4OMultiplyAB_V__6142509188972423790_contiguous.cpp:13     
  7:1503: error: declaration of 'operator+' as non-function                                   
  137 | inline complex64_t operator+(const std::complex<float>& x, const complex64_t&         
  y) { return x + static_cast<std::complex<float>>(y); } inline complex64_t                   
  operator+(const complex64_t& x, const std::complex<float>& y) { return                      
  static_cast<std::complex<float>>(x) + y; } inline complex64_t operator+(const               
  complex64_t& x, const complex64_t& y) { return static_cast<std::complex<float>>(x) +        
  static_cast<std::complex<float>>(y); } inline complex64_t operator+(bool x, const           
  complex64_t& y) { return static_cast<complex64_t>(x) + y; } inline complex64_t              
  operator+(const complex64_t& x, bool y) { return x + static_cast<complex64_t>(y); }         
  inline complex64_t operator+(uint32_t x, const complex64_t& y) { return                     
  static_cast<complex64_t>(x) + y; } inline complex64_t operator+(const complex64_t& x,       
  uint32_t y) { return x + static_cast<complex64_t>(y); } inline complex64_t                  
  operator+(uint64_t x, const complex64_t& y) { return static_cast<complex64_t>(x) + y; }     
  inline complex64_t operator+(const complex64_t& x, uint64_t y) { return x +                 
  static_cast<complex64_t>(y); } inline complex64_t operator+(int32_t x, const                
  complex64_t& y) { return static_cast<complex64_t>(x) + y; } inline complex64_t              
  operator+(const complex64_t& x, int32_t y) { return x + static_cast<complex64_t>(y); }      
  inline complex64_t operator+(int64_t x, const complex64_t& y) { return                      
  static_cast<complex64_t>(x) + y; } inline complex64_t operator+(const complex64_t& x,       
  int64_t y) { return x + static_cast<complex64_t>(y); } inline complex64_t                   
  operator+(float16_t x, const complex64_t& y) { return static_cast<complex64_t>(x) + y;      
  } inline complex64_t operator+(const complex64_t& x, float16_t y) { return x +              
  static_cast<complex64_t>(y); } inline complex64_t operator+(bfloat16_t x, const             
  complex64_t& y) { return static_cast<complex64_t>(x) + y; } inline complex64_t              
  operator+(const complex64_t& x, bfloat16_t y) { return x + static_cast<complex64_t>(y);     
  } inline complex64_t operator+(float x, const complex64_t& y) { return                      
  static_cast<complex64_t>(x) + y; } inline complex64_t operator+(const complex64_t& x,       
  float y) { return x + static_cast<complex64_t>(y); }                                        
  |                                                                                           
                                                                                              
                                                                                              
                                                                                              
                                                                                              
                                                                                              
                                                                                              
                                                                                              
                                                                                              
                                                                                              
                                                                                              
                                                                                              
                                                                                              
                                                                                              
                                                                                              
                                                                                              
                                                                                              
  ^~~~~~~~                                                                                    
  /tmp/mlx/0.24.2/cpu/Bf4ISigmoidACf4OMultiplyAB_V__6142509188972423790_contiguous.cpp:13     
  7:1513: error: 'float16_t' was not declared in this scope; did you mean 'bfloat16_t'?       
  137 | inline complex64_t operator+(const std::complex<float>& x, const complex64_t&         
  y) { return x + static_cast<std::complex<float>>(y); } inline complex64_t                   
  operator+(const complex64_t& x, const std::complex<float>& y) { return                      
  static_cast<std::complex<float>>(x) + y; } inline complex64_t operator+(const               
  complex64_t& x, const complex64_t& y) { return static_cast<std::complex<float>>(x) +        
  static_cast<std::complex<float>>(y); } inline complex64_t operator+(bool x, const           
  complex64_t& y) { return static_cast<complex64_t>(x) + y; } inline complex64_t              
  operator+(const complex64_t& x, bool y) { return x + static_cast<complex64_t>(y); }         
  inline complex64_t operator+(uint32_t x, const complex64_t& y) { return                     
  static_cast<complex64_t>(x) + y; } inline complex64_t operator+(const complex64_t& x,       
  uint32_t y) { return x + static_cast<complex64_t>(y); } inline complex64_t                  
  operator+(uint64_t x, const complex64_t& y) { return static_cast<complex64_t>(x) + y; }     
  inline complex64_t operator+(const complex64_t& x, uint64_t y) { return x +                 
  static_cast<complex64_t>(y); } inline complex64_t operator+(int32_t x, const                
  complex64_t& y) { return static_cast<complex64_t>(x) + y; } inline complex64_t              
  operator+(const complex64_t& x, int32_t y) { return x + static_cast<complex64_t>(y); }      
  inline complex64_t operator+(int64_t x, const complex64_t& y) { return                      
  static_cast<complex64_t>(x) + y; } inline complex64_t operator+(const complex64_t& x,       
  int64_t y) { return x + static_cast<complex64_t>(y); } inline complex64_t                   
  operator+(float16_t x, const complex64_t& y) { return static_cast<complex64_t>(x) + y;      
  } inline complex64_t operator+(const complex64_t& x, float16_t y) { return x +              
  static_cast<complex64_t>(y); } inline complex64_t operator+(bfloat16_t x, const             
  complex64_t& y) { return static_cast<complex64_t>(x) + y; } inline complex64_t              
  operator+(const complex64_t& x, bfloat16_t y) { return x + static_cast<complex64_t>(y);     
  } inline complex64_t operator+(float x, const complex64_t& y) { return                      
  static_cast<complex64_t>(x) + y; } inline complex64_t operator+(const complex64_t& x,       
  float y) { return x + static_cast<complex64_t>(y); }                                        
  |                                                                                           
                                                                                              
                                                                                              
                                                                                              
                                                                                              
                                                                                              
                                                                                              
                                                                                              
                                                                                              
                                                                                              
                                                                                              
                                                                                              
                                                                                              
                                                                                              
                                                                                              
                                                                                              
                                                                                              
  ^~~~~~~~~                                                                                   
  |                                                                                           
                                                                                              
                                                                                              
                                                                                              
                                                                                              
                                                                                              
                                                                                              
                                                                                              
                                                                                              
                                                                                              
                                                                                              
                                                                                              
                                                                                              
                                                                                              
                                                                                              
                                                                                              
                                                                                              
  bfloat16_t                                                                                  
  /tmp/mlx/0.24.2/cpu/Bf4ISigmoidACf4OMultiplyAB_V__6142509188972423790_contiguous.cpp:13     
  7:1526: error: expected primary-expression before 'const'                                   
  137 | inline complex64_t operator+(const std::complex<float>& x, const complex64_t&         
  y) { return x + static_cast<std::complex<float>>(y); } inline complex64_t                   
  operator+(const complex64_t& x, const std::complex<float>& y) { return                      
  static_cast<std::complex<float>>(x) + y; } inline complex64_t operator+(const               
  complex64_t& x, const complex64_t& y) { return static_cast<std::complex<float>>(x) +        
  static_cast<std::complex<float>>(y); } inline complex64_t operator+(bool x, const           
  complex64_t& y) { return static_cast<complex64_t>(x) + y; } inline complex64_t              
  operator+(const complex64_t& x, bool y) { return x + static_cast<complex64_t>(y); }         
  inline complex64_t operator+(uint32_t x, const complex64_t& y) { return                     
  static_cast<complex64_t>(x) + y; } inline complex64_t operator+(const complex64_t& x,       
  uint32_t y) { return x + static_cast<complex64_t>(y); } inline complex64_t                  
  operator+(uint64_t x, const complex64_t& y) { return static_cast<complex64_t>(x) + y; }     
  inline complex64_t operator+(const complex64_t& x, uint64_t y) { return x +                 
  static_cast<complex64_t>(y); } inline complex64_t operator+(int32_t x, const                
  complex64_t& y) { return static_cast<complex64_t>(x) + y; } inline complex64_t              
  operator+(const complex64_t& x, int32_t y) { return x + static_cast<complex64_t>(y); }      
  inline complex64_t operator+(int64_t x, const complex64_t& y) { return                      
  static_cast<complex64_t>(x) + y; } inline complex64_t operator+(const complex64_t& x,       
  int64_t y) { return x + static_cast<complex64_t>(y); } inline complex64_t                   
  operator+(float16_t x, const complex64_t& y) { return static_cast<complex64_t>(x) + y;      
  } inline complex64_t operator+(const complex64_t& x, float16_t y) { return x +              
  static_cast<complex64_t>(y); } inline complex64_t operator+(bfloat16_t x, const             
  complex64_t& y) { return static_cast<complex64_t>(x) + y; } inline complex64_t              
  operator+(const complex64_t& x, bfloat16_t y) { return x + static_cast<complex64_t>(y);     
  } inline complex64_t operator+(float x, const complex64_t& y) { return                      
  static_cast<complex64_t>(x) + y; } inline complex64_t operator+(const complex64_t& x,       
  float y) { return x + static_cast<complex64_t>(y); }                                        
  |                                                                                           
                                                                                              
                                                                                              
                                                                                              
                                                                                              
                                                                                              
                                                                                              
                                                                                              
                                                                                              
                                                                                              
                                                                                              
                                                                                              
                                                                                              
                                                                                              
                                                                                              
                                                                                              
                                                                                              
  ^~~~~                                                                                       
  /tmp/mlx/0.24.2/cpu/Bf4ISigmoidACf4OMultiplyAB_V__6142509188972423790_contiguous.cpp:13     
  7:1643: error: 'float16_t' has not been declared                                            
  137 | inline complex64_t operator+(const std::complex<float>& x, const complex64_t&         
  y) { return x + static_cast<std::complex<float>>(y); } inline complex64_t                   
  operator+(const complex64_t& x, const std::complex<float>& y) { return                      
  static_cast<std::complex<float>>(x) + y; } inline complex64_t operator+(const               
  complex64_t& x, const complex64_t& y) { return static_cast<std::complex<float>>(x) +        
  static_cast<std::complex<float>>(y); } inline complex64_t operator+(bool x, const           
  complex64_t& y) { return static_cast<complex64_t>(x) + y; } inline complex64_t              
  operator+(const complex64_t& x, bool y) { return x + static_cast<complex64_t>(y); }         
  inline complex64_t operator+(uint32_t x, const complex64_t& y) { return                     
  static_cast<complex64_t>(x) + y; } inline complex64_t operator+(const complex64_t& x,       
  uint32_t y) { return x + static_cast<complex64_t>(y); } inline complex64_t                  
  operator+(uint64_t x, const complex64_t& y) { return static_cast<complex64_t>(x) + y; }     
  inline complex64_t operator+(const complex64_t& x, uint64_t y) { return x +                 
  static_cast<complex64_t>(y); } inline complex64_t operator+(int32_t x, const                
  complex64_t& y) { return static_cast<complex64_t>(x) + y; } inline complex64_t              
  operator+(const complex64_t& x, int32_t y) { return x + static_cast<complex64_t>(y); }      
  inline complex64_t operator+(int64_t x, const complex64_t& y) { return                      
  static_cast<complex64_t>(x) + y; } inline complex64_t operator+(const complex64_t& x,       
  int64_t y) { return x + static_cast<complex64_t>(y); } inline complex64_t                   
  operator+(float16_t x, const complex64_t& y) { return static_cast<complex64_t>(x) + y;      
  } inline complex64_t operator+(const complex64_t& x, float16_t y) { return x +              
  static_cast<complex64_t>(y); } inline complex64_t operator+(bfloat16_t x, const             
  complex64_t& y) { return static_cast<complex64_t>(x) + y; } inline complex64_t              
  operator+(const complex64_t& x, bfloat16_t y) { return x + static_cast<complex64_t>(y);     
  } inline complex64_t operator+(float x, const complex64_t& y) { return                      
  static_cast<complex64_t>(x) + y; } inline complex64_t operator+(const complex64_t& x,       
  float y) { return x + static_cast<complex64_t>(y); }                                        
  |                                                                                           
                                                                                              
                                                                                              
                                                                                              
                                                                                              
                                                                                              
                                                                                              
                                                                                              
                                                                                              
                                                                                              
                                                                                              
                                                                                              
                                                                                              
                                                                                              
                                                                                              
                                                                                              
                                                                                              
                                                                                              
                                                                                              
  ^~~~~~~~~                                                                                   
  /tmp/mlx/0.24.2/cpu/Bf4ISigmoidACf4OMultiplyAB_V__6142509188972423790_contiguous.cpp:13     
  7:1611: error: redefinition of 'mlx::core::complex64_t mlx::core::operator+(const           
  mlx::core::complex64_t&, int)'                                                              
  137 | inline complex64_t operator+(const std::complex<float>& x, const complex64_t&         
  y) { return x + static_cast<std::complex<float>>(y); } inline complex64_t                   
  operator+(const complex64_t& x, const std::complex<float>& y) { return                      
  static_cast<std::complex<float>>(x) + y; } inline complex64_t operator+(const               
  complex64_t& x, const complex64_t& y) { return static_cast<std::complex<float>>(x) +        
  static_cast<std::complex<float>>(y); } inline complex64_t operator+(bool x, const           
  complex64_t& y) { return static_cast<complex64_t>(x) + y; } inline complex64_t              
  operator+(const complex64_t& x, bool y) { return x + static_cast<complex64_t>(y); }         
  inline complex64_t operator+(uint32_t x, const complex64_t& y) { return                     
  static_cast<complex64_t>(x) + y; } inline complex64_t operator+(const complex64_t& x,       
  uint32_t y) { return x + static_cast<complex64_t>(y); } inline complex64_t                  
  operator+(uint64_t x, const complex64_t& y) { return static_cast<complex64_t>(x) + y; }     
  inline complex64_t operator+(const complex64_t& x, uint64_t y) { return x +                 
  static_cast<complex64_t>(y); } inline complex64_t operator+(int32_t x, const                
  complex64_t& y) { return static_cast<complex64_t>(x) + y; } inline complex64_t              
  operator+(const complex64_t& x, int32_t y) { return x + static_cast<complex64_t>(y); }      
  inline complex64_t operator+(int64_t x, const complex64_t& y) { return                      
  static_cast<complex64_t>(x) + y; } inline complex64_t operator+(const complex64_t& x,       
  int64_t y) { return x + static_cast<complex64_t>(y); } inline complex64_t                   
  operator+(float16_t x, const complex64_t& y) { return static_cast<complex64_t>(x) + y;      
  } inline complex64_t operator+(const complex64_t& x, float16_t y) { return x +              
  static_cast<complex64_t>(y); } inline complex64_t operator+(bfloat16_t x, const             
  complex64_t& y) { return static_cast<complex64_t>(x) + y; } inline complex64_t              
  operator+(const complex64_t& x, bfloat16_t y) { return x + static_cast<complex64_t>(y);     
  } inline complex64_t operator+(float x, const complex64_t& y) { return                      
  static_cast<complex64_t>(x) + y; } inline complex64_t operator+(const complex64_t& x,       
  float y) { return x + static_cast<complex64_t>(y); }                                        
  |                                                                                           
                                                                                              
                                                                                              
                                                                                              
                                                                                              
                                                                                              
                                                                                              
                                                                                              
                                                                                              
                                                                                              
                                                                                              
                                                                                              
                                                                                              
                                                                                              
                                                                                              
                                                                                              
                                                                                              
                                                                                              
  ^~~~~~~~                                                                                    
  /tmp/mlx/0.24.2/cpu/Bf4ISigmoidACf4OMultiplyAB_V__6142509188972423790_contiguous.cpp:13     
  7:1185: note: 'mlx::core::complex64_t mlx::core::operator+(const                            
  mlx::core::complex64_t&, int32_t)' previously defined here                                  
  137 | inline complex64_t operator+(const std::complex<float>& x, const complex64_t&         
  y) { return x + static_cast<std::complex<float>>(y); } inline complex64_t                   
  operator+(const complex64_t& x, const std::complex<float>& y) { return                      
  static_cast<std::complex<float>>(x) + y; } inline complex64_t operator+(const               
  complex64_t& x, const complex64_t& y) { return static_cast<std::complex<float>>(x) +        
  static_cast<std::complex<float>>(y); } inline complex64_t operator+(bool x, const           
  complex64_t& y) { return static_cast<complex64_t>(x) + y; } inline complex64_t              
  operator+(const complex64_t& x, bool y) { return x + static_cast<complex64_t>(y); }         
  inline complex64_t operator+(uint32_t x, const complex64_t& y) { return                     
  static_cast<complex64_t>(x) + y; } inline complex64_t operator+(const complex64_t& x,       
  uint32_t y) { return x + static_cast<complex64_t>(y); } inline complex64_t                  
  operator+(uint64_t x, const complex64_t& y) { return static_cast<complex64_t>(x) + y; }     
  inline complex64_t operator+(const complex64_t& x, uint64_t y) { return x +                 
  static_cast<complex64_t>(y); } inline complex64_t operator+(int32_t x, const                
  complex64_t& y) { return static_cast<complex64_t>(x) + y; } inline complex64_t              
  operator+(const complex64_t& x, int32_t y) { return x + static_cast<complex64_t>(y); }      
  inline complex64_t operator+(int64_t x, const complex64_t& y) { return                      
  static_cast<complex64_t>(x) + y; } inline complex64_t operator+(const complex64_t& x,       
  int64_t y) { return x + static_cast<complex64_t>(y); } inline complex64_t                   
  operator+(float16_t x, const complex64_t& y) { return static_cast<complex64_t>(x) + y;      
  } inline complex64_t operator+(const complex64_t& x, float16_t y) { return x +              
  static_cast<complex64_t>(y); } inline complex64_t operator+(bfloat16_t x, const             
  complex64_t& y) { return static_cast<complex64_t>(x) + y; } inline complex64_t              
  operator+(const complex64_t& x, bfloat16_t y) { return x + static_cast<complex64_t>(y);     
  } inline complex64_t operator+(float x, const complex64_t& y) { return                      
  static_cast<complex64_t>(x) + y; } inline complex64_t operator+(const complex64_t& x,       
  float y) { return x + static_cast<complex64_t>(y); }                                        
  |                                                                                           
                                                                                              
                                                                                              
                                                                                              
                                                                                              
                                                                                              
                                                                                              
                                                                                              
                                                                                              
                                                                                              
                                                                                              
                                                                                              
                                                                                              
  ^~~~~~~~                                                                                    
  /tmp/mlx/0.24.2/cpu/Bf4ISigmoidACf4OMultiplyAB_V__6142509188972423790_contiguous.cpp:       
  In function 'mlx::core::simd::Simd<T, 1>                                                    
  mlx::core::simd::clamp(mlx::core::simd::Simd<T, 1>, mlx::core::simd::Simd<T, 1>,            
  mlx::core::simd::Simd<T, 1>)':                                                              
  /tmp/mlx/0.24.2/cpu/Bf4ISigmoidACf4OMultiplyAB_V__6142509188972423790_contiguous.cpp:34     
  2:15: error: 'clamp' is not a member of 'std'; did you mean 'mlx::core::simd::clamp'?       
  342 |   return std::clamp(v.value, min.value, max.value);                                   
  |               ^~~~~                                                                       
  /tmp/mlx/0.24.2/cpu/Bf4ISigmoidACf4OMultiplyAB_V__6142509188972423790_contiguous.cpp:34     
  1:12: note: 'mlx::core::simd::clamp' declared here                                          
  341 | Simd<T, 1> clamp(Simd<T, 1> v, Simd<T, 1> min, Simd<T, 1> max) {                      
  |            ^~~~~                                                                          
  /tmp/mlx/0.24.2/cpu/Bf4ISigmoidACf4OMultiplyAB_V__6142509188972423790_contiguous.cpp:       
  In instantiation of 'mlx::core::simd::Simd<float, N>                                        
  mlx::core::detail::fp32_from_bits(mlx::core::simd::Simd<unsigned int, N>) [with int N =     
  1]':                                                                                        
  /tmp/mlx/0.24.2/cpu/Bf4ISigmoidACf4OMultiplyAB_V__6142509188972423790_contiguous.cpp:62     
  0:26:   required from 'mlx::core::simd::Simd<float, N>                                      
  mlx::core::detail::FromFP8::operator()(mlx::core::simd::Simd<unsigned char, N>) [with       
  int N = 1]'                                                                                 
  /tmp/mlx/0.24.2/cpu/Bf4ISigmoidACf4OMultiplyAB_V__6142509188972423790_contiguous.cpp:62     
  3:19:   required from here                                                                  
  /tmp/mlx/0.24.2/cpu/Bf4ISigmoidACf4OMultiplyAB_V__6142509188972423790_contiguous.cpp:56     
  8:11: warning: dereferencing type-punned pointer will break strict-aliasing rules           
  [-Wstrict-aliasing]                                                                         
  568 |   return *(Simd<float, N>*)(&x);                                                      
  |           ^~~~~~~~~~~~~~~~~~~~~                                                           
  /tmp/mlx/0.24.2/cpu/Bf4ISigmoidACf4OMultiplyAB_V__6142509188972423790_contiguous.cpp:56     
  8:11: warning: dereferencing type-punned pointer will break strict-aliasing rules           
  [-Wstrict-aliasing]                                                                         
  /tmp/mlx/0.24.2/cpu/Bf4ISigmoidACf4OMultiplyAB_V__6142509188972423790_contiguous.cpp:       
  In instantiation of 'mlx::core::simd::Simd<T, N>                                            
  mlx::core::simd::exp(mlx::core::simd::Simd<T, N>) [with T = float; int N = 1]':             
  /tmp/mlx/0.24.2/cpu/Bf4ISigmoidACf4OMultiplyAB_V__6142509188972423790_contiguous.cpp:53     
  8:38:   required from 'mlx::core::simd::Simd<T, N>                                          
  mlx::core::detail::Sigmoid::operator()(mlx::core::simd::Simd<T, N>) [with int N = 1; T      
  = float]'                                                                                   
  /tmp/mlx/0.24.2/cpu/Bf4ISigmoidACf4OMultiplyAB_V__6142509188972423790_contiguous.cpp:54     
  1:59:   required from 'T mlx::core::detail::Sigmoid::operator()(T) [with T = float]'        
  /tmp/mlx/0.24.2/cpu/Bf4ISigmoidACf4OMultiplyAB_V__6142509188972423790_contiguous.cpp:69     
  5:26:   required from here                                                                  
  /tmp/mlx/0.24.2/cpu/Bf4ISigmoidACf4OMultiplyAB_V__6142509188972423790_contiguous.cpp:37     
  6:51: warning: dereferencing type-punned pointer will break strict-aliasing rules           
  [-Wstrict-aliasing]                                                                         
  376 |     auto result = select(isnan(x_init), x_init, (*(Simd<float, N>*)&epart) *          
  x);                                                                                         
  |                                                   ^~~~~~~~~~~~~~~~~~~~~~~                 
  /tmp/mlx/0.24.2/cpu/Bf4ISigmoidACf4OMultiplyAB_V__6142509188972423790_contiguous.cpp:37     
  6:51: warning: dereferencing type-punned pointer will break strict-aliasing rules           
  [-Wstrict-aliasing]                                                                         
  /tmp/mlx/0.24.2/cpu/Bf4ISigmoidACf4OMultiplyAB_V__6142509188972423790_contiguous.cpp:25     
  6:65: note:   initializing argument 1 of 'mlx::core::simd::Simd<decltype ((a.value *        
  b.value)), 1> mlx::core::simd::operator*(mlx::core::simd::Simd<T, 1>,                       
  mlx::core::simd::Simd<T2, 1>) [with T1 = float; T2 = float; decltype ((a.value *            
  b.value)) = float]'                                                                         
  256 | template <typename T1, typename T2> auto operator *(Simd<T1, 1> a, Simd<T2, 1>        
  b) ->Simd<decltype(a.value * b.value), 1> { return a.value * b.value; } template            
  <typename T1, typename T2> auto operator *(T1 a, Simd<T2, 1> b)->Simd<decltype(a *          
  b.value), 1> { return a * b.value; } template <typename T1, typename T2> auto operator      
  *(Simd<T1, 1> a, T2 b)->Simd<decltype(a.value * b), 1> { return a.value * b; }              
  |                                                     ~~~~~~~~~~~~^ at                      
  /app/.build/checkouts/mlx-swift/Source/Cmlx/mlx-c/mlx/c/transforms.cpp:15

Metadata

Metadata

Assignees

No one assigned

    Labels

    No labels
    No labels

    Type

    No type

    Projects

    No projects

    Milestone

    No milestone

    Relationships

    None yet

    Development

    No branches or pull requests

    Issue actions